Contenido

Experiencia de Aprendizaje 3: Implementación del modelo en una base de datos. ......................... 3

Lenguaje SQL - Structured Query Language.................................................................................... 3
Elementos de un código desarrollado en SQL............................................................................. 4
Significado del formato de las sentencias SQL. ........................................................................... 5
Consideraciones para construir una sentencia SQL. ................................................................... 5
Arquitectura de un Servidor de Base de Datos Oracle................................................................ 6
¿Cómo crear una base de datos en Oracle Cloud? ......................................................................... 7
¿Cómo conectarse a la base de datos creada en Oracle Cloud?................................................... 13
¿Cómo crear un usuario para conectarse a la base de datos?...................................................... 15
Cuentas de Usuarios de Base de Datos. .................................................................................... 15
¿Qué son los privilegios? ........................................................................................................... 17
¿Qué son los roles? ................................................................................................................... 19
¿Qué es un Tablespace? ............................................................................................................ 21
Creación de Usuario en Oracle SQL Developer. ........................................................................ 21
Creando sentencias SQL para construir el modelo físico. ............................................................. 24
SQL DDL. .................................................................................................................................... 24
Creación de base de datos. ....................................................................................................... 25
Creación de tablas. .................................................................................................................... 25
Modificación de tablas. ............................................................................................................. 28
Cambio de nombre de una tabla. .......................................................................................... 28
Agregar una columna a una tabla. ........................................................................................ 28
Eliminar una columna a una tabla. ........................................................................................ 29
Modificar el tipo de datos de una columna. ......................................................................... 29
Renombrar una columna....................................................................................................... 29
Eliminar una tabla. ................................................................................................................ 30
Creación de columnas auto-incrementables. ........................................................................... 30
Creación de columnas auto-incrementables ALWAYS. ......................................................... 31
Creación de columnas auto-incrementables BY DEFAULT. ................................................... 31
Creación de columnas auto-incrementables BY DEFAULT ON NULL. ................................... 31
Creación de columnas auto-incrementables de forma manual. ............................................... 31
Creando sentencias SQL para crear restricciones en el modelo físico.......................................... 33

1
 Restricción NOT NULL. .............................................................................................................. 34
Restricción UNIQUE. .................................................................................................................. 35
Restricción PRIMARY KEY. ......................................................................................................... 35
Restricción FOREIGN KEY. ......................................................................................................... 35
Restricción CHECK. .................................................................................................................... 36
Añadir restricciones................................................................................................................... 36
Borrar restricciones. .................................................................................................................. 36
¿Cómo usar Oracle SQL Developer Data Modeler para construir sentencia DDL? ....................... 36
¿Cómo usar Oracle SQL Developer para construir el modelo físico? ........................................... 38
Comenzando con las sentencias SQL. ....................................................................................... 39
Creando sentencias SQL para poblar y manipular datos en el modelo físico. .............................. 48
SQL DML. ................................................................................................................................... 48
Sentencia SELECT................................................................................................................... 48
Sentencia INSERT. ................................................................................................................. 48
Sentencia DELETE. ................................................................................................................. 49
Sentencia UPDATE. ................................................................................................................ 49
Transacción de una base de datos. ........................................................................................... 49
¿Cómo usar Oracle SQL Developer para poblar y manipular los datos del modelo físico? .......... 50
¿Por qué desnormalizamos un modelo normalizado?.................................................................. 57
¿Cómo podemos desnormalizar?.............................................................................................. 58
Almacenamiento de valores calculados. ............................................................................... 58
Unión de tablas. .................................................................................................................... 59
Separación de tablas. ............................................................................................................ 59
Agregar valores asociados a la temporalidad. ...................................................................... 60
Creación de tablas. ................................................................................................................ 61

2
Experiencia de Aprendizaje 3: Implementación del modelo en una base de
datos.
Lenguaje SQL - Structured Query Language.
El precursor del lenguaje SQL fue el lenguaje SEQUEL (Structured English Query Language),
implementado por IBM como parte del proyecto System R, por la década de los 70 del siglo pasado.
En 1986 ANSI (American National Standards Institute) e ISO (International Standards Organization)
publicaron por primera vez la primera norma SQL, denominada SQL-86. Así nació uno de los
lenguajes más utilizados a nivel mundial.
A través de los años, el lenguaje SQL ha sufrido variaciones con la finalidad de establecer una
estructura unificada y comprensible por diversos profesionales y motores de base de datos.
El lenguaje SQL rápidamente se popularizó y fue incluido en los gestores de bases de datos más
populares como son Microsoft SQL Server, Oracle, SyBase, MySQL, Firebird, Informix, PostgreSQL,
DB2, etc. Y además de los gestores de bases de datos, muchos lenguajes de programación basan sus
motores de acceso a datos en el uso de comandos SQL para ejecutar los movimientos de datos de
las aplicaciones desarrolladas en su entorno.
Los comandos utilizados en SQL para ejecutar las diferentes acciones pueden ser muy sencillos para
obtener datos muy generales hasta muy complejos para obtener datos más detallados.
No obstante, aunque exista un estándar definido por ANSI, existen particularidades entre los
diferentes gestores de bases de datos en la gestión SQL. Por ejemplo: el lenguaje SQL de Oracle no
es exactamente el mismo que el de Microsoft SQL Server. Normalmente las diferencias son mínimas,
pero existen.
Los comandos de SQL se dividen en 4 grandes grupos:
1. Lenguaje de Definición de Datos (DDL - Data Definition Language): Permite definir la estructura
de las bases de datos. Por ejemplo:
 CREATE: Sentencias de creación de objetos.
 ALTER: Modificación de alguna estructura.
 DROP: Eliminación de objetos.
 RENAME: Cambiar nombre de los objetos.
 TRUNCATE: Eliminación de todos los registros de una tabla.
 COMMENT: Coloca un comentario en el diccionario de datos.
2. Lenguaje de Manipulación de Datos (DML - Data Management Language): Permite acceder a los
datos almacenados. Por ejemplo:

3
  SELECT: Sentencias para consultar datos.
 INSERT: Inserción de datos.
 UPDATE: Modificación de datos.
 DELETE: Eliminación de registros de una tabla.
 MERGE: Actualiza e inserta datos.
3. Lenguaje de Control de Datos (DCL - Data Control Language): Permite definir controles de
seguridad sobre objetos de la base de datos. Son principalmente dos:
 GRANT: Otorga permisos a los usuarios sobre los objetos de la base de datos.
 REVOKE: Quita permisos a los usuarios sobre los objetos de la base de datos.
4. Lenguaje de Control de Transacciones (TCL - Transaction Control Lenguage): Permiten confirmar
(COMMIT) o deshacer (ROLLBACK) cambios realizados por las sentencias DML. Si se utiliza
SAVEPOINT se permite deshacer el trabajo realizado después de declarado el savepoint dentro
de una transacción.

DDL DML DCL TCL

• CREATE • SELECT • GRANT • COMMIT
• ALTER • INSERT • REVOKE • ROLLBACK
• DROP • UPDATE • SAVEPOINT
• RENAME • DELETE
• TRUNCATE • MERGE
• COMMENT

Elementos de un código desarrollado en SQL.

Al usar SQL para construir una solución, ésta puede contener los siguientes elementos:
 Comandos SQL: DML, DDL, DCL, etc.
 Palabras reservadas: Hacen referencia a un elemento SQL individual. Ejemplos: SELECT, FROM,
WHERE, JOIN, etc.
 Cláusulas: Es una parte de una sentencia SQL. Ejemplo: SELECT employee_id, last_name
 Sentencia: Es una combinación de dos o más cláusulas. Ejemplo: SELECT employee_id,
last_name FROM employees;

4
 Operadores: Permiten crear expresiones complejas. Pueden ser aritméticos (+, -, /, *), de
comparación (>, <, >=, …) o lógicos (AND, OR, NOT).
 Funciones: Pueden ser de carácter, fecha, números, generales. Ejemplos: SYSDATE, NVL(),
ROUND(), etc. También existen funciones para conseguir valores complejos, pueden ser
agregadas o de grupo. Ejemplos: SUM(), MIN(), COUNT(), etc.
 Constantes: Valores literales para las consultas. Pueden ser números, textos, caracteres, fechas,
etc.

Significado del formato de las sentencias SQL.

SELECT {* | columna | expresión [alias],...}

FROM tabla;
En la sintaxis de una sentencia SQL, aparecen una serie de símbolos que significan lo siguiente:
 [] (corchetes): Sirven para encerrar texto que NO es obligatorio en el comando, es decir, para
indicar una parte opcional.
 |(barra vertical): Indica opción, es decir, que se puede elegir entre varias opciones.
 ... (puntos suspensivos): Indica que se puede repetir el texto anterior en el comando
continuamente (significaría y así sucesivamente).
 { } (llaves): Indican opciones mutuamente exclusivas pero obligatorias. Es decir, opciones de las
que sólo se puede elegir una opción, pero de las que es obligatorio elegir una.

Consideraciones para construir una sentencia SQL.

 Las sentencias SQL NO son Case-Sensitive (sensible a las mayúsculas).
 Las sentencias SQL pueden ser una o más líneas.
 Las palabras reservadas no pueden ser abreviadas o continuar en líneas diferentes.
 Las cláusulas son normalmente escritas en líneas diferentes.
 Las sentencias SQL deben terminar con un punto y coma (;).
Se sugiere que las palabras reservadas sean escritas en mayúsculas y el resto en minúsculas.

5
Arquitectura de un Servidor de Base de Datos Oracle
 Un servidor de base de datos Oracle consta de una instancia y una base de datos.
 Una instancia Oracle es un medio de acceso a una base de datos Oracle por la que siempre abre
una única base de datos, la cual está formada por estructuras de procesos en segundo plano y
de memoria. Una instancia Oracle se compone de la estructura de la memoria SGA (Área Global
del Sistema) y de los procesos background que se utilizan para gestionar una base de datos.
 La base de datos almacena y recupera la información relacionada. Una base de datos Oracle
tiene una estructura lógica y una física. La estructura física de la base de datos es el juego de
archivos del sistema operativo en la base de datos.
 La estructura física incluye tres tipos de archivos: Archivos de control, archivos de datos y
archivos redo log online.

6
¿Cómo crear una base de datos en Oracle Cloud?
Para crear una base de datos en Oracle Cloud se deben seguir los siguientes pasos:

1. Para conectarte a Oracle Cloud se debe ingresar a https://www.oracle.com/cl/cloud/sign-

in.html. Si recuerdas el nombre de tu cuenta Cloud debes ingresarla y presionar el botón Next.
En caso de haber olvidado el nombre presiona Get help para conseguir el nombre que definiste
al activar tu cuenta.

7
2. Al presionar el botón Next será desplegada la siguiente página donde debes presionar el botón
Continue.

3. Debes ingresar con tu correo institucional y la contraseña que definiste al crear tu cuenta en
Oracle Cloud.

8
4. Una vez dentro del portal debes seleccionar la opción Create an ATP database.

5. En el campo Display name puede colocar el nombre de la base de datos que creará. Se sugiere
no cambiar el nombre en el campo Database name.

9
6. Seleccione en tipo de carga de trabajo Transaction Processing y en tipo de despliegue Shared
Infrastructure. Finalmente se debe mantener seleccionada la opción Show only Always Free
configuration options.

7. Las siguientes opciones se deben dejar por defecto, ya que son las que se utilizan en nuestra
versión de convenio.

10
8. En la sección Create administrator credentials debes definir una contraseña para el usuario
ADMIN de la base de datos.

9. Las opciones Tipo de Acceso y Tipo de Licencia se deben dejar con los valores por defecto.

10. Finalmente, se debe presionar el botón Create Autonomous Database. La creación de la base
de datos demora unos minutos y aparece en estado PROVISIONING.

11
11. Una vez creada la base de datos aparece en estado AVAILABLE y es posible ver las acciones que
se pueden ejecutar.

12. Para poder conectarse a la base de datos es necesario bajar un archivo que nos permite realizar
la conexión. Debes presionar el botón DB Connections, en el campo Wallet type se debe
seleccionar Instance Wallet y luego presione el botón Download wallet.

12
13. Se debe ingresar la contraseña creada anteriormente y presionar el botón Download.

14. El archivo Zip descargado debe ser guardado porque será ocupado más adelante.

¿Cómo conectarse a la base de datos creada en Oracle Cloud?

Para conectarse a la base de datos creada en Oracle Cloud es necesario descargar el programa
Oracle SQL Developer. Esta es una herramienta gráfica gratuita que mejora la productividad y
simplifica las tareas de desarrollo de bases de datos. Con SQL Developer se pueden examinar los
objetos de la base de datos, ejecutar sentencias SQL y scripts SQL, editar y depurar sentencias
PL/SQL, manipular y exportar datos, y ver y crear informes.
Para descargar el software Oracle SQL Developer debe acceder al siguiente link:
https://www.oracle.com/tools/downloads/sqldev-downloads.html.
Al igual que el programa Oracle SQL Developer Data Modeler el archivo descargado se debe
descomprimir y ejecutar el archivo sqldeveloper.exe que se encuentra en la carpeta sqldeveloper.

13
Una vez iniciado el programa, se debe presionar el icono + verde para crear una nueva conexión.

Luego, se debe colocar un nombre a la conexión en el campo Name y en el campo Tipo Conexión
seleccionar Cartera de Cloud. El usuario de la conexión debes ser ADMIN (en mayúsculas) y la
contraseña es la definida al crear la base de datos, es muy importante que en el campo Archivo de
Configuración sea seleccionado el archivo de cartera Cloud descargado anteriormente.

Para finalizar se debe presionar el botón Probar y luego Conectar, entonces se desplegará una
ventana donde se encuentra una hoja que permite trabajar en la base de datos.

14
¿Cómo crear un usuario para conectarse a la base de datos?
Cuentas de Usuarios de Base de Datos.
Desde el punto de vista de base de datos, un usuario es un conjunto de permisos que se aplican a
una conexión de base de datos, para que pueda manipular objetos de la base de datos y efectuar
acciones en la base de datos.
Para acceder a una base de datos, se debe especificar una cuenta de usuario de base de datos válida
y autenticarse correctamente según los requisitos de dicha cuenta. Cada usuario de base de datos
debería tener una cuenta de base de única. Esto es recomendable para evitar posibles problemas
de seguridad y proporcionar datos significativos cuando se efectúan ciertas auditorías. Sin embargo,
cuando los usuarios comparten una cuenta de base de datos común, el sistema operativo y las
aplicaciones deben proporcionar la seguridad para la base de datos.

15
Una cuenta de usuario tiene las siguientes características:
 Nombre de usuario único: Los nombres de usuarios no pueden contener más de 30 caracteres,
ni contener caracteres especiales y deben comenzar con una letra.
 Método de autenticación: El método más común de autenticación es una contraseña (o
password), pero Oracle 11g soporta los métodos de autenticación por contraseña, global y
externa (como la autenticación biométrica, certificado y token).
 Tablespace por defecto: Este el lugar en el que el usuario creará objetos si no se especifica
ningún otro al momento de crear la cuenta. Si embargo, para que el usuario pueda crear objetos
en ese tablespace se le debe otorgar los privilegios que corresponden. Para este tablespace se
debe indicar cuánto espacio cuánto es el espacio que el usuario podrá usar.
 Tablespace temporal: Es un lugar en el que la base de datos, por ejemplo, realiza el
ordenamiento de los datos y creará las tablas temporales del usuario. Para este tablespace no
se indica cuánto es el espacio que el usuario podrá usar.
 Perfil de usuario: Es un conjunto de restricciones de recursos y contraseñas asignadas al
usuario. Si no se le asigna un perfil específico, la base de datos le asigna un perfil por defecto ya
definido en la base de datos.
 Grupo consumidor inicial: Es una opción de que utiliza el gestor de recursos de la base de datos.

16
 Estado de cuenta: Los usuarios solo pueden acceder a las cuentas cuando están desbloqueadas
(estado OPEN). Las cuentas pueden tener el estado de bloqueada o caducada.
En una base de datos Oracle existen varias cuentas predefinidas para efectuar las tareas de
administración de la base de datos y no para tareas rutinarias. Las cuentas de usuarios más
conocidas son SYS, SYSTEM y ADMIN las que tienen otorgado por defecto el rol de administrador de
base de datos (DBA). Además, la cuenta SYS es propietaria del diccionario de datos. Para conectarse
a la cuenta SYS, se debe utilizar la cláusula AS SYSDBA. Las cuentas ADMIN y SYSTEM tienen
otorgados roles especiales para efectuar la mayoría de las tareas de administración de la base de
datos. Las cuentas SYS y SYSTEM son cuentas necesarias en la base de datos, por lo tanto, no se
pueden eliminar.

¿Qué son los privilegios?

Un privilegio es el derecho a ejecutar sentencias SQL particulares o acceder a objetos existentes en
la base de datos. El administrador de la base de datos (DBA) es un usuario de alto nivel que puede
crear usuarios y otorgarles acceso a la base de datos y sus objetos. Los usuarios requieren privilegios
del sistema para realizar acciones en la base de datos y privilegios de objetos para manipular el
contenido de los objetos en la base de datos. A los usuarios también se les puede otorgar el

17
privilegio de otorgar privilegios adicionales a otros usuarios o roles, que se denominan grupos de
privilegios relacionados.
Cada vez que se deben otorgar privilegios a los usuarios, siempre se debe seguir el principio del
menor privilegio que indica que los usuarios deben recibir la menor cantidad de privilegios para
realizar sus trabajos.
Los privilegios de usuarios deben ser revisados con regularidad para determinar la relevancia con
las responsabilidades actuales de los puestos.
Al hablar de privilegios surgen inmediatamente los conceptos de usuario y esquema de base de
datos. Un usuario se puede definir como conjunto de permisos que se aplican a una conexión de
base de datos. Un esquema es un conjunto de objetos como tablas, vistas, programas, secuencias,
etc. El esquema es propiedad de un usuario de la base de datos y tiene el mismo nombre que ese
usuario.
Los privilegios de usuario deben ser revisados periódicamente para determinar la relevancia de las
responsabilidades de trabajo actuales y determinar que privilegios están siendo realmente
utilizados por un usuario. Los mecanismos de control de privilegios de los roles de trabajo han de
ser bien definidos o mantenidos. Esta revisión periódica se da porque las organizaciones
constantemente están cambiando, el recurso humano también, nuevas personas son contratadas,
otras dejan la organización y otro grupo cambia de puesto y a su vez de responsabilidades.

18
Al momento de crear un usuario, se deben otorgar los privilegios mínimos para poder operar con
una base de datos. El privilegio CREATE SESSION para conectarse a la base de datos, es el privilegio
mínimo para cualquier usuario.

¿Qué son los roles?

Los roles son un conjunto de privilegios que se pueden otorgar a diferentes usuarios o a otros roles.
Las características de los roles son los siguientes:
 Se pueden otorgar a cualquier usuario o rol.
 Su nombre debe ser distinto a cualquier otro nombre de usuario o rol en la BD.
 No están asociados a ningún esquema.
Varios son los beneficios de usar roles:
 Simplifican el manejo de privilegios. Los permisos se pueden asignar a un rol y éste a los
diferentes usuarios.
 Manejo de privilegios dinámico. Si se modifican los privilegios asociados al rol, todos los usuarios
que lo posean los adquieren de forma inmediata.

19
 Disponibilidad de privilegios selectiva. Roles asignados a un usuario pueden ser activados o
desactivados temporalmente.
 Mejora de la productividad. El uso de roles disminuye el número de privilegios almacenados en
el diccionario de datos de la base de datos.

Al momento de crear un usuario, se deben otorgar los roles mínimos para poder operar con una
base de datos. Cuando creas un nuevo usuario en la base de datos de Oracle, el usuario desea
realizar alguna acción como: Crear tablas o triggers bajo su propio esquema. Para realizar estas
acciones, se debe otorgar al usuario el rol de RESOURCE. Este rol incluye los siguientes privilegios
implícitamente:
 CREATE TYPE.
 CREATE TABLE.
 CREATE CLUSTER.
 CREATE TRIGGER.
 CREATE OPERATOR.
 CREATE SEQUENCE.
 CREATE INDEXTYPE.
 CREATE PROCEDURE.

20
¿Qué es un Tablespace?
Cuando se crea un objeto como tabla, vistas, claves primarias e índices se debe crear en un
tablespace determinado. Un tablespace es una unidad lógica de almacenamiento dentro de una
base de datos Oracle y es el nexo con el almacenamiento físico en el sistema de archivo del Sistema
Operativo. Cada tablespace se compone al menos de un datafile (archivo de datos) y un datafile solo
puede pertenecer a un tablespace.
Los tablespace de la base de datos los crea el DBA o un usuario que tenga el privilegio de sistema
CREATE TABLESPACE.

Creación de Usuario en Oracle SQL Developer.

Una vez conectado a la base de datos se sugiere crear una cuenta de usuario distinta a la del
administrador, que tenga los privilegios suficientes para conectarse y ejecutar sentencias SQL.
Para crear un usuario se debe acceder a la opción de menú Otros Usuarios.

21
Luego, se debe presionar el botón derecho del mouse y se desplegará un menú contextual donde
se debe presionar Crear Usuario…

En la siguiente ventana se debe completar el nombre de usuario y la contraseña. En Tablespace por

defecto se debe seleccionar DATA y en Tablespace Temporal seleccionar TEMP.

En la pestaña Roles Otorgados seleccionar marcar las opciones Otorgado y Valor por Defecto del rol
RESOURCE.

22
En la pestaña Privilegios del Sistema marcar la opción Otorgado del privilegio CREATE SESSION.

Finalmente, en la pestaña Cuotas se debe marcar la opción Ilimitado para el Tablespace DATA y
presionamos el botón Aplicar.

23
Entonces será desplegado un mensaje de confirmación de la creación del usuario.

Ahora, es posible crear una nueva conexión para conectar con el nuevo usuario.

Creando sentencias SQL para construir el modelo físico.

SQL DDL.
La finalidad de estos comandos es la de crear, modificar o eliminar los objetos de la base de datos
que sirven para gestionar datos. Estos objetos están contenidos en esquemas y los esquemas están
contenidos en catálogos, de esta forma un objeto debe llamarse de la siguiente forma:
catalogo.esquema.objeto
Oracle no posee catálogos. Sin embargo, sí existen esquemas. Los esquemas de Oracle están
relacionados con los usuarios: cada usuario posee un esquema (con el mismo nombre del usuario)
pensado para almacenar sus objetos.

24
Creación de base de datos.
Crear una base de datos implica indicar los archivos y ubicaciones de éstos. Sólo es posible crear
una base de datos con permisos de DBA (Data Base Administrator).
Si se desea crear una base de datos a través de SQL se usa la siguiente sentencia:
CREATE DATABASE PRUEBA;
Donde PRUEBA es el nombre de la base de datos. Esta instrucción bastaría para crear una base de
datos, pero en Oracle es necesario definir algunos parámetros:
CREATE DATABASE prueba
LOGFILE prueba.log
MAXLOGFILES 25
MAXINSTANCES 10
ARCHIVELOG
CHARACTER SET WIN1214
NATIONAL CHARACTER SET AL32UTF8
DATAFILE pruebal.dbf AUTOEXTEND ON MAXSIZE 500MB;

Para esta asignatura será utilizado Oracle Cloud y la base de datos se creará desde la página Web,
no se utilizarán sentencias SQL.

Creación de tablas.
En Oracle los nombres de las tablas deben cumplir con las siguientes condiciones:
 Deben comenzar con una letra.
 No deben tener más de 30 caracteres.
 Solo se permiten utilizar letras del alfabeto (inglés), números o el signo de subrayado
(también los signos $ y #, pero esos se utilizan de manera especial, por lo que no son
recomendados).
 No puede haber dos tablas con el mismo nombre dentro del mismo esquema. Pueden
coincidir los nombres si están en distintos esquemas.
 No puede coincidir con el nombre de una palabra reservada SQL. Por ejemplo, no se puede
llamar SELECT a una tabla.
 En el caso de que el nombre tenga espacios en blanco o caracteres nacionales (permitido
solo en algunas bases de datos). Entonces, se suele colocarlas entre comillas dobles. En el

25
 estándar SQL 99 (respetado por Oracle) se pueden utilizar comillas dobles al poner el nombre
de la tabla a fin de hacerla sensible a las mayúsculas. Se diferenciará
entre “FACTURA” y “Factura”.

IMPORTANTE: Esto aplica para cualquier nombre de objeto en una base de datos.

Los tipos de datos que Oracle usa son mostrados a continuación:

Tipo de dato Descripción

VARCHAR2(tamaño) Tipo de dato de caracteres de longitud variable. Se debe

especificar su tamaño. Tamaño mínimo: 1, tamaño máximo:
4000.
NVARCHAR2(tamaño) Similar a VARCHAR2 (tamaño) que contiene datos Unicode
formateados.
CHAR[(tamaño)] Tipo de dato de caracteres de longitud fija. Su tamaño mínimo es
1 y el máximo es 2000.
NCHAR (tamaño) Similar a CHAR (tamaño) que contiene datos Unicode
formateados.
LONG Dato de caracteres de longitud variable de hasta 2 gigabytes
(versión más grande que VARCHAR2).
RAW Un tipo binario de longitud variable para almacenar datos de
caracteres. Almacena hasta 2.000 bytes.
LONG RAW Un tipo binario de longitud variable para almacenar datos de
caracteres. Almacena hasta 2 gigabytes.
NUMBER(precisión,escala) Tipo de dato numérico de longitud variable. La precisión indica el
largo total y la escala los decimales. Si no se indica la escala, el
número será un valor entero.
El rango para la precisión va desde 1 a 38. El rango para la escala
va desde -84 to 127.
BINARY_FLOAT Contiene valores numéricos de coma flotante de hasta 32 bits.
Para su almacenamiento requiere 4 bytes.
BINARY_DOUBLE Contiene valores numéricos de coma flotante de hasta 64 bits.
Para su almacenamiento requiere 8 bytes.
FLOAT(b) Almacena un número en punto decimal sin restricción de dígitos
decimales. El parámetro b indica la precisión binaria máxima que
puede moverse en el rango 1 a 126.
DATE Valores de fecha y hora.
TIMESTAMP [(precisión)] Es una extensión de DATE, almacena año, mes, día, hora, minuto,
segundo y fracción de segundo. La precisión indica el número de

26
 Tipo de dato Descripción

dígitos para la fracción de segundos. El rango es de 0 a 9 y el valor

por defecto es 6.
TIMESTAMP WITH TIME Es una extensión de TIMESTAMP, almacena lo mismo más la
ZONE fecha y hora correspondientes a la zona horaria específica para la
base de datos.
TIMESTAMP WITH LOCAL Es una extensión de TIMESTAMP, almacena lo mismo más la
TIME ZONE fecha y hora donde se encuentra físicamente el servidor de base
de datos.
INTERVAL YEAR TO MONTH Almacena un período de tiempo en años y meses.
INTERVAL DAY TO SECOND Almacena un período de tiempo en días, horas, minutos y
segundos.
BLOB Dato binario de hasta 4 gigabytes.

BFILE Dato binario almacenado fuera de la BD; de hasta 4 gigabytes.

CLOB Dato de caracteres de longitud variable de hasta 4 gigabytes.

NCLOB Similar a CLOB, pero los caracteres son almacenados en un
conjunto de caracteres Unicode de varios bytes.
ROWID Almacena la dirección lógica de ubicación del registro en la tabla.
El valor se representa en formato carácter con base 64.

La sintaxis básica para crear una tabla es usar CREATE TABLE seguido del nombre de la tabla,
después entre paréntesis se van declarando las columnas que conformarán la tabla, entre columna
y columna se debe usar el separador coma “,”. Las columnas deben tener un nombre de columna
representativo y un tipo de dato, de manera opcional se puede asignar un valor por defecto
(DEFAULT).
Por defecto la tabla será almacenada en el espacio y esquema del usuario que crea la tabla.

IMPORTANTE: Para indicar que la sentencia ha terminado se debe colocar el símbolo punto y coma
“;” al final de la sentencia.

SINTAXIS CREACIÓN TABLA:

CREATE TABLE [esquema.]nombreTabla(
nombreColumna1 tipoDato [DEFAULT valor] [restricciones],
…
);

27
Los corchetes “[ ]” en la sintaxis definida significa que es opcional.
Ejemplo:
CREATE TABLE PROVEEDOR(
nombre VARCHAR(25),
localidad VARCHAR(30) DEFAULT 'Santiago' );

IMPORTANTE: Las comillas simples se utilizan para los valores que son alfanúmericos.

El ejemplo anterior se crea la tabla PROVEEDOR con dos columnas:

1. nombre cuyo tamaño máximo es 25 caracteres.
2. localidad cuyo tamaño máximo es 30 caracteres y el valor por defecto es ‘Santiago’ cuando
no se define el valor al ingresar un registro.

Modificación de tablas.
Para modificar una tabla existe el comando ALTER TABLE que permite modificar las propiedades de
una tabla.

Cambio de nombre de una tabla.

Para realizar el cambio del nombre de una tabla que ya se encuentra creada se pueden utilizar las
siguientes sintaxis:
SINTAXIS CAMBIO NOMBRE:
 SQL estándar para modificar el nombre de una tabla:
ALTER TABLE nombreTabla RENAME TO nuevoNombre;

 SQL Oracle para modificar el nombre de cualquier objeto:

RENAME nombreTabla TO nuevoNombre;

Agregar una columna a una tabla.

Para agregar un campo obligatorio (NOT NULL) la tabla debe estar vacía o debe especificarse un
valor por defecto.
SINTAXIS AGREGAR COLUMNA:
ALTER TABLE nombreTabla ADD(nombreColumnaNueva TipoDato [propiedades],…);
Ejemplo:
ALTER TABLE FACTURA ADD (fecha DATE);

28
En el ejemplo, es agregada la columna fecha en la tabla FACTURA.

Eliminar una columna a una tabla.

No pueden eliminarse las columnas a los cuales hace referencia una restricción Foreign Key. Si se
elimina una columna que tiene una restricción, ésta también se elimina. NO puede eliminarse una
columna si es la única en la tabla.
SINTAXIS ELIMINAR COLUMNA:
ALTER TABLE nombreTabla DROP(Columna1, …);
Ejemplo:
ALTER TABLE FACTURA DROP (fecha);
En el ejemplo, es eliminada la columna fecha de la tabla FACTURA.

Modificar el tipo de datos de una columna.

En Oracle los cambios que se permiten en las columnas son:
 Incrementar precisión o largo de los tipos de datos.
 Solo se puede reducir el largo de un campo si los valores existentes tienen un largo menor
o igual al nuevo largo.
 Se puede pasar de CHAR a VARCHAR2 y viceversa (si no se modifica el largo).
 Se puede pasar de DATE a TIMESTAMP y viceversa.
 Cualquier otro cambio solo es posible si la tabla está vacía.
 Si se modifica el valor de la propiedad DEFAULT de una columna de una tabla, dicho cambio
solo tendrá efecto en la inserción de nuevas filas.
SINTAXIS MODIFICAR COLUMNA:
ALTER TABLE nombreTabla MODIFY (columna tipo [propiedades],…);
Ejemplo:
ALTER TABLE FACTURA MODIFY (fecha TIMESTAMP);
En el ejemplo, es modificado el tipo de dato DATE de la columna fecha al tipo de dato TIMESTAMP.

Renombrar una columna.

Es posible cambiar el nombre de una columna en una tabla.
SINTAXIS RENOMBRAR COLUMNA:
ALTER TABLE nombreTabla RENAME COLUMN nombreAntiguo TO nombreNuevo;
Ejemplo:
ALTER TABLE FACTURA RENAME COLUMN fecha TO fechayhora;
En el ejemplo, es modificado el nombre de la columna fecha a fechayhora.

29
Eliminar una tabla.
La sentencia DROP TABLE seguida del nombre de una tabla, permite eliminar la tabla en cuestión.
Al borrar una tabla:
 Desaparecen todos los datos de la tabla.
 Cualquier vista y sinónimo referente a la tabla seguirá existiendo, pero ya no funcionará.
 Las transacciones pendientes son aceptadas en aquellas bases de datos que tengan la
posibilidad de utilizar transacciones.
 Solo se pueden eliminar las tablas sobre las que el usuario tiene permiso de borrado.
Normalmente, el borrado de una tabla es irreversible por lo que conviene ser muy cuidadoso con
esta operación. Sin embargo, existe en Oracle una posibilidad de recuperación mediante el
comando FLASHBACK TABLE si se ha configurado la papelera de reciclaje.
Este comando permite usar al final de la palabra PURGE. Este hace que el borrado de la tabla sea
irreversible porque la tabla no pasa a la papelera de reciclaje.
SINTAXIS ELIMINAR TABLA:
DROP TABLE nombreTabla;
DROP TABLE nombreTabla PURGE;

Creación de columnas auto-incrementables.

A contar de la versión Oracle 12c, se puede utilizar un nuevo atributo a nivel de columna de la tabla,
conocido como identidad a nivel de columna (Identity Column). Esto permite que una columna
pueda autoincrementarse automáticamente, como se hacen en otros motores de base de datos.
Una tabla puede tener sólo una columna IDENTITY. En estas columnas no se pueden modificar los
valores que se definieron para realizar el autoincremento.
El incremento automático permite generar automáticamente un número único cuando se inserta
un nuevo registro en una tabla. Este número comienza en 1 y su incremento es 1. Existen 3 tipos de
auto-incrementales que se usan al crear la tabla: ALWAYS, BY DEFAULT y BY DEFAULT ON NULL.
SINTAXIS COLUMNA AUTO-INCREMENTAL:
COLUMN NAME GENERATED [ALWAYS|BY DEFAULT [ON NULL]] AS IDENTITY [(identity_options)]

30
Creación de columnas auto-incrementables ALWAYS.
Define que no es necesario escribir explícitamente el valor de la columna en la sentencia de
inserción de datos, y si se coloca dándole un valor incluso válido, arrojará el siguiente error: “ORA-
32795: cannot insert into a generated always identity columna”.
Ejemplo:
CREATE TABLE PRUEBA(
idprueba NUMBER(19) GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
nombre VARCHAR2(50));

Creación de columnas auto-incrementables BY DEFAULT.

Para este caso si en la sentencia de inserción se coloca explícitamente el valor, éste será almacenado
en la columna. En cambio, al omitir el valor para la columna será generado un número que se
incrementará automáticamente. Si se escribe un valor nulo (NULL) en la sentencia de inserción será
desplegado un error debido a que todo campo definido como IDENTITY no permite nulos (NOT
NULL).
Ejemplo:
CREATE TABLE PRUEBA(
idprueba NUMBER(19) GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
nombre VARCHAR2(50));

Creación de columnas auto-incrementables BY DEFAULT ON NULL.

Para este caso si en la sentencia de inserción se coloca explícitamente el valor, éste será almacenado
en la columna. En cambio, al omitir el valor o escribir un valor nulo (NULL) para la columna será
generado un número que se incrementará automáticamente.
Ejemplo:
CREATE TABLE PRUEBA(
idprueba NUMBER(19) GENERATED BY DEFAULT ON NULL AS IDENTITY PRIMARY KEY,
nombre VARCHAR2(50));

Creación de columnas auto-incrementables de forma manual.

Una secuencia (SEQUENCE) se emplea para generar valores enteros secuenciales únicos y
asignárselos a campos numéricos. Se utilizan generalmente para las claves primarias de las tablas
garantizando que sus valores no se repitan.
Una secuencia es una tabla con un campo numérico en el cual se almacena un valor y cada vez que
se consulta, se incrementa tal valor para la próxima consulta.

31
SINTAXIS SECUENCIA:
CREATE SEQUENCE NOMBRESECUENCIA START WITH valorentero
INCREMENT BY valorentero
MAXVALUE valorentero
MINVALUE valorentero
CYCLE | NOCYCLE;
A continuación, se detallan las cláusulas de la sintaxis:
 START WITH: Indica el valor desde el cual comenzará la generación de números secuenciales.
Si no se especifica, se inicia con el valor que indique MINVALUE.
 INCREMENT BY: Especifica el incremento, es decir, la diferencia entre los números de la
secuencia. Debe ser un valor numérico entero positivo o negativo diferente de 0. Si no se
indica, por defecto es 1.
 MAXVALUE: Define el valor máximo para la secuencia. Si se omite, por defecto es
99999999999999999999999999.
 MINVALUE: Establece el valor mínimo de la secuencia. Si se omite será 1.
 CYCLE|NOCYCLE: Indica que, cuando la secuencia llegue a máximo valor se reinicie,
comenzando con el mínimo valor nuevamente. es decir, la secuencia vuelve a utilizar los
números. Si se omite, por defecto la secuencia se crea NOCYCLE.
Si no se especifica ninguna cláusula, excepto el nombre de la secuencia, por defecto comenzará en
1, se incrementará en 1, el mínimo valor será 1, el máximo será 999999999999999999999999999 y
NOCYCLE.
En el siguiente ejemplo se crea una secuencia llamada SEQ_LIBRO, estableciendo que comience en
1, sus valores estén entre 1 y 99999, se incremente en 1 y por defecto será NOCYCLE:

CREATE SEQUENCE SEQ_LIBRO

START WITH 1
INCREMENT BY 1
MAXVALUE 99999
MINVALUE 1;
Si bien, las secuencias son independientes de las tablas, se utilizarán generalmente para una tabla
específica. Por lo tanto, es conveniente darle un nombre que referencie a la misma.
Otro ejemplo:

32
CREATE SEQUENCE SEQ_SOCIO
INCREMENT BY 5
MAXVALUE 1000000
CYCLE;
La secuencia anterior SEQ_SOCIO, incrementa sus valores en 5, el valor máximo es 1000000 y al
llegar al máximo valor recomenzará la secuencia desde el valor mínimo. No se especifican las otras
cláusulas, por lo tanto, por defecto el valor mínimo es 1 y el valor inicial es 1.

Creando sentencias SQL para crear restricciones en el modelo físico.

Una restricción es una condición que se debe cumplir obligatoriamente para una o más columnas
de la tabla. Las restricciones se pueden realizar cuando es creada (CREATE) o modificada (ALTER)
una tabla. Existen dos maneras de poner restricciones:
 Restricción de columna: En este caso la restricción se coloca seguido a la definición de la
columna.
SINTAXIS RESTRICCIÓN COLUMNA:
…
nombreColumna1 tipoDato [DEFAULT expresión] [CONSTRAINT nombre] tipo,
…

 Restricción de tabla: En este caso las restricciones se colocan al final de la lista de columnas.
SINTAXIS RESTRICCIÓN TABLA:
…
columna1 definición1,
columna2 definición2,
…,
últimacolumna últimadefinición,
[CONSTRAINT nombre] tipo (listaColumnas)
[, … otras restricciones…]
…
Es buena práctica asignar un nombre a las restricciones, ya que el nombre que le asigna Oracle no
es representativo. Se sugiere la siguiente estructura:

33
 3 letras
3 letras
del
Tipo de del
_ nombre _
restricción nombre
de la
de la tabla
columna

Por ejemplo, para la tabla ALUMNO donde la columna código del alumno es la clave primaria, el
nombre de la restricción podría ser PK_COD_ALU.
El tipo de restricción en el nombre de la restricción deben ser 2 letras, para cada tipo de restricción
se muestran las letras a usar:
NN: NOT NULL.
UN: UNIQUE.
PK: PRIMARY KEY.
FK: FOREIGN KEY.
CK: CHECK.
A continuación, se muestra la descripción de cada tipo de restricción:

Restricción Descripción

NOT NULL Especifica que la columna no podrá almacenar valores

nulos.

UNIQUE Especifica que el valor de la columna debe ser único para

todas las filas en la tabla. No puede ser referenciada como
foránea.

PRIMARY KEY Identifica en forma única cada fila de la tabla y puede ser
referenciada como foránea.

FOREIGN KEY Establece y hace cumplir una relación de clave foránea

entre la columna de la tabla a crear y una columna de la
tabla referenciada.

CHECK Especifica una condición que debe ser verdadera para los
valores que almacenará la columna.

Restricción NOT NULL.

Usada para prohibir los nulos en una columna de la tabla.

34
Ejemplo:
CREATE TABLE CLIENTE(
idcliente VARCHAR(10) CONSTRAINT NN_IDC_CLI NOT NULL,
NOMBRE VARCHAR(50));
Para el ejemplo, se crea una restricción de NOT NULL en la columna idcliente de la tabla CLIENTE.

Restricción UNIQUE.
Usada para especificar que el valor de la columna debe ser único.
Ejemplo:
CREATE TABLE CLIENTE(
idcliente VARCHAR(10) CONSTRAINT UN_IDC_CLI UNIQUE,
NOMBRE VARCHAR(50));
Para el ejemplo, se crea una restricción de valor único en la columna idcliente de la tabla CLIENTE.

Restricción PRIMARY KEY.

Usada para definir una columna que defina cada fila como única.
Ejemplo:
CREATE TABLE CLIENTE(
idcliente VARCHAR(10) CONSTRAINT PK_IDC_CLI PRIMARY KEY,
NOMBRE VARCHAR(50));
Para el ejemplo, se crea una restricción de clave primaria en la columna idcliente de la tabla CLIENTE.

Restricción FOREIGN KEY.

Usada para crear las relaciones entre las tablas.
Ejemplo:
CREATE TABLE ARRIENDO(
idcliente VARCHAR(10) CONSTRAINT FK_IDC_CLI REFERENCES CLIENTE(idcliente),
codpelicula NUMBER(5) CONSTRAINT FK_COD_PEL REFERENCES PELICULA(codpelicula),
CONSTRAINT PK_IDC_COD_ALQ PRIMARY KEY (idcliente, codpelicula)
);
Para el ejemplo, se crean dos restricciones de clave foránea en la tabla ARRIENDO. En la columna
idcliente se hace referencia a la columna del mismo nombre de la tabla CLIENTE y en la columna
codpelicula se hace referencia a la columna del mismo nombre de la tabla PELICULA.
Adicionalmente, se definen para las columnas idcliente y codpelicula una restricción de clave
primaria.

35
Restricción CHECK.
Usada para incorporar una validación que se debe cumplir almacenar el dato en la columna.
Ejemplo: Las restricciones incorporadas solo permiten valores entre 0 y 8000 para la columna
importe.
CREATE TABLE INGRESO(
cod NUMBER(5) PRIMARY KEY,
concepto VARCHAR2(40) NOT NULL,
importe NUMBER(11,2) CONSTRAINT CK1_IMP_ING CHECK (importe>=0) CONSTRAINT
CK2_IMP_ING CKECK (importe<=8000));
La siguiente restricción valida que el importe sea menor que el importe máximo.
CREATE TABLE INGRESO(
cod NUMBER(5) PRIMARY KEY,
concepto VARCHAR2(40) NOT NULL,
importe_max NUMBER(11,2),
importe NUMBER(11,2),
CONSTRAINT CK_IMP_ING CHECK (importe < importe_max));
La sintaxis vista hasta el momento permite agregar restricciones en la sentencia de creación de las
tablas. Además, es posible agregar restricciones cuando la tabla ya está creada.

Añadir restricciones.
Usada para agregar restricciones en una tabla existente.
SINTAXIS AGREGAR RESTRICCIÓN:
ALTER TABLE nombreTabla ADD [CONSTRAINT nombre] tipoRestriccion (columnas);

Borrar restricciones.
Usada para eliminar restricciones de una tabla.
SINTAXIS BORRAR RESTRICCIÓN:
ALTER TABLE nombreTabla DROP {PRIMARY KEY | UNIQUE (columnas) | CONSTRAINT
nombreRestriccion} [CASCADE];

¿Cómo usar Oracle SQL Developer Data Modeler para construir sentencia DDL?
Una vez que el modelo relacional está completo se puede generar el archivo que contiene el código
SQL que genera las tablas, restricciones, índices, claves foráneas y vistas. Para realizar esta tarea se

debe presionar el icono Generar DDL (cilindro gris).

36
En la ventana del Editor de Archivo DDL se debe seleccionar la versión de código SQL a generar. Para
el caso de esta asignatura seleccione la versión de Oracle que esté utilizando o la más cercana.

Al presionar el botón Generar será desplegada la siguiente ventana donde se pueden seleccionar
los componentes del modelo que se desean incluir:

Una vez seleccionados los componentes se debe presionar el botón Aceptar, entonces será
generado un archivo con las sentencias DDL del modelo relacional. El archivo generado se puede
guardar para ser usado posteriormente en el SGBD seleccionado.

37
¿Cómo usar Oracle SQL Developer para construir el modelo físico?
Para construir el modelo físico es necesario conectarse a la base de datos a través de la herramienta
Oracle SQL Developer como se mostró en las secciones anteriores. Cuando esté conectado será
desplegada la siguiente ventana:

38
Como se puede apreciar en la imagen la conexión tiene un icono en forma de cilindro con un enchufe
que indica que está conectada. La presionar el signo + se muestran todos los objetos que puede
contener la instancia creada. Por ejemplo: Tablas, vistas, índices, paquetes, procedimientos,
funciones, operadores, etc.
En esta sección se mostrará cómo trabajar en Oracle SQL Developer Data Modeler con sentencias
DDL. Para comenzar se explicará el uso de algunos iconos importantes en la ventana donde se
escriben las sentencias SQL.

 El icono permite ejecutar la(s) sentencia (s) que está(n) seleccionada(s) en la Hoja de Trabajo.

 El icono permite ejecutar en forma secuencial todas las sentencias que estén escritas en la
Hoja de Trabajo.

 El icono COMMIT permite confirmar las transacciones realizadas al ejecutar las sentencias
SQL.

 El icono ROLLBACK permite deshacer las transacciones realizadas al ejecutar las sentencias
SQL.
 Los símbolos -- se utilizan para colocar comentarios en las sentencias SQL. Al ser comentarios el
programa no lo tomará como sentencia a ejecutar.

Comenzando con las sentencias SQL.

Lo primero que se realizará en la aplicación es crear una tabla, se debe escribir la sentencia de
creación de tabla en la Hoja de Trabajo y ejecutar para que sea creada la tabla. Para el ejemplo, se
utilizará la sentencia que crea la tabla DEPARTAMENTO.
-- Creación tabla
CREATE TABLE DEPARTAMENTO(
iddepartamento NUMBER(9),
nombre VARCHAR2(100),

39
descripcion VARCHAR2(300),
fecha_creacion DATE DEFAULT SYSDATE);
Una vez ejecutada la sentencia en la parte inferior aparecerá un mensaje indicando que la tabla fue
creada.

Para revisar si la tabla fue creada se debe validar en la opción Tablas de la conexión. Primero se
debe presionar el botón derecho sobre la opción y seleccionar Refrescar en el menú contextual
desplegado.

Entonces, aparecerá la tabla y al presionar el signo + serán desplegadas las columnas de la tabla.

Al hacer clic sobre el nombre de la tabla será desplegada información más detallada de las columnas
de la tabla DEPARTAMENTO.

40
Una vez creada la tabla se usarán dos sentencias para cambiar el nombre de la tabla. Para el ejemplo,
las sentencias se deben ejecutar por separado.
-- Renombrar tabla
ALTER TABLE DEPARTAMENTO RENAME TO DEPARTAMENTOS;
RENAME DEPARTAMENTOS TO DEPARTAMENTO;
Al ejecutar la primera sentencia es mostrado el siguiente mensaje:

Al actualizar se puede apreciar que el nombre de la tabla DEPARTAMENTO ha cambiado a

DEPARTAMENTOS.

Al ejecutar la segunda sentencia se muestra un mensaje de confirmación del cambio y al actualizar

se puede ver que el nombre de la tabla DEPARTAMENTOS ha cambiado a DEPARTAMENTO.

Si se requiere agregar una columna a una tabla se puede realizar a través de una sentencia SQL. Para
el ejemplo, se agregará la columna fecha a la tabla DEPARTAMENTO.
-- Agregar columna a tabla
ALTER TABLE DEPARTAMENTO ADD (fecha DATE);
Una vez ejecutada la sentencia será mostrado un mensaje de confirmación del cambio y al actualizar
se puede ver que la columna fue incorporada a la tabla DEPARTAMENTO.

41
Ahora se modificará el tipo de dato de la columna fecha. Actualmente, el tipo de dato es DATE y
será cambiado a TIMESTAMP.
-- Modificar tipo de dato
ALTER TABLE DEPARTAMENTO MODIFY (fecha TIMESTAMP);
Al ejecutar la sentencia se muestra un mensaje de confirmación del cambio y al actualizar se observa
que el tipo de dato de la columna fecha fue cambiado.

Para eliminar la columna fecha desde la tabla DEPARTAMENTO se debe ejecutar la siguiente
sentencia:
-- Eliminar campo a tabla
ALTER TABLE DEPARTAMENTO DROP (fecha);
Al ejecutar la sentencia se muestra un mensaje de confirmación del cambio y al actualizar se puede
ver que la columna fecha ya no se encuentra en la tabla DEPARTAMENTO.

42
Otra modificación que se puede realizar en una tabla es cambiar el nombre de una columna. Para el
ejemplo, se cambiará el nombre de la columna iddepartamento por id_departamento con la
sentencia que se muestra a continuación:
-- Renombrar campo
ALTER TABLE DEPARTAMENTO RENAME COLUMN iddepartamento TO id_departamento;
Cuando la sentencia es ejecutada se muestra un mensaje de confirmación del cambio y al actualizar
se puede ver que el nombre de la columna iddepartamento fue cambiado por id_departamento.

Finalmente, será eliminada la tabla EMPLEADO con la siguiente sentencia:

-- Eliminar tabla
DROP TABLE DEPARTAMENTO;

43
Al ejecutar la sentencia se muestra un mensaje de confirmación de la eliminación y al actualizar la
tabla ya no se encuentra.

Una vez vistas las sentencias DDL serán revisadas las sentencias que permiten crear restricciones.
La siguiente sentencia permite generar una restricción donde no se permiten valores nulos en la
columna idempleado de la tabla EMPLEADO.
-- Constraint NOT NULL
CREATE TABLE EMPLEADO(
idempleado NUMBER(9) CONSTRAINT NN_IDE_EMP NOT NULL,
nombre VARCHAR2(100));
Al ejecutar la sentencia se muestra un mensaje de confirmación de la creación de la tabla y al
seleccionar la tabla se pueden apreciar las columnas.

Al seleccionar la pestaña Restricciones se muestra el detalle de la restricción creada.

IMPORTANTE: Para continuar con los ejemplos, es necesario eliminar la tabla EMPLEADO antes de
volver a crearla. No pueden existir dos tablas con el mismo nombre.

La siguiente sentencia permite generar una restricción donde los valores de la columna idempleado
de la tabla EMPLEADO deben ser únicos (aunque no sea clave primaria).
-- Constraint UNIQUE
CREATE TABLE EMPLEADO(

44
idempleado NUMBER(9) CONSTRAINT UN_IDE_EMP UNIQUE,
nombre VARCHAR2(100));
Una vez ejecutada la sentencia se muestra un mensaje de confirmación de la creación de la tabla y
al seleccionar la pestaña Restricciones de la tabla se puede apreciar el detalle de la restricción.

En el siguiente ejemplo, la sentencia crea la tabla DEPARTAMENTO donde la columna

id_departamento es la clave primaria.
-- Constraint PRIMARY KEY
CREATE TABLE DEPARTAMENTO(
id_departamento NUMBER(9) CONSTRAINT PK_IDD_DEP PRIMARY KEY,
nombre VARCHAR2(100));
Al ejecutar la sentencia se muestra un mensaje de confirmación de la creación de la tabla y en la
pestaña Restricciones de la tabla se puede apreciar el detalle de la restricción.

Con la sentencia que se muestra a continuación, se crea la tabla EMPLEADO donde se genera una
restricción de clave foránea para relacionarla con la tabla DEPARTAMENTO.
--Constraint FOREIGN KEY
CREATE TABLE EMPLEADO(
rut VARCHAR(10) CONSTRAINT PK_RUT_EMP PRIMARY KEY,
nombre VARCHAR(50),
id_departamento NUMBER(9) CONSTRAINT FK_IDD_DEP REFERENCES
DEPARTAMENTO(id_departamento));
Cuando es ejecutada la sentencia es desplegado un mensaje de confirmación de la creación de la
tabla y al seleccionar la tabla se puede ver el detalle de las columnas.

45
Al seleccionar la pestaña Restricciones se muestra el detalle de las restricciones creadas.

Si se desea ver la relación de forma gráfica se debe seleccionar la pestaña Modelo.

Finalmente, se crearán sentencias que permiten crear restricciones de validación. La siguiente

sentencia crea la tabla INGRESO e incorpora dos restricciones de CHECK para validar que el valor del
importe se encuentre entre 0 y 8000.
--Constraint CHECK
CREATE TABLE INGRESO(

46
COD VARCHAR(10) PRIMARY KEY,
CONCEPTO VARCHAR2(40) NOT NULL,
IMPORTE NUMBER(11,2) CONSTRAINT CK1_IMP_ING CHECK (IMPORTE>=0) CONSTRAINT
CK2_IMP_ING CHECK (IMPORTE<=8000));
Al ejecutar la sentencia se muestra un mensaje de confirmación de la creación de la tabla y al
seleccionar la tabla se puede ver el detalle de las columnas.

Al seleccionar la pestaña Restricciones se muestra el detalle de las restricciones creadas.

La siguiente sentencia crea una restricción donde los valores que pueden ser ingresados en la
columna descripcionestadocivil son: Soltero, Casado, Viudo, Divorciado y Conviviente Civil.
-- Constraint CHECK
CREATE TABLE ESTADO_CIVIL (
idestadocivil NUMBER PRIMARY KEY,
descripcionestadocivil VARCHAR2(30) NOT NULL CONSTRAINT CK_DES_EST CHECK
(descripcionestadocivil IN ('Soltero','Casado','Viudo','Divorciado', 'Conviviente Civil')));
La ejecución de la sentencia muestra un mensaje de confirmación de la creación de la tabla y al
seleccionar la tabla se puede ver el detalle de las columnas.

47
Al seleccionar la pestaña Restricciones se muestra el detalle de las restricciones creadas.

Creando sentencias SQL para poblar y manipular datos en el modelo físico.

SQL DML.
El lenguaje de manipulación de datos es un lenguaje proporcionado por los sistemas gestores de
bases de datos (SGBD) que permite a los usuarios llevar a cabo las tareas de consulta, inserción,
eliminación o modificación de los datos contenidos en la base de datos.
Los principales elementos del lenguaje de manipulación de datos son: SELECT, INSERT, DELETE y
UPDATE.

Sentencia SELECT.
Permite consultar los datos que contenga una tabla.
SINTAXIS SELECT:
SELECT *
FROM NombreTabla;
La query anterior se lee: “Seleccionar todas las filas de la tabla NombreTabla”.

IMPORTANTE: El símbolo * en el SELECT significa que serán mostradas todas las columnas de la
tabla.

Es posible indicar cuales son las columnas que se desean mostrar y limitar las filas que devuelve la
consulta con el condicionador WHERE. Por ejemplo:
SELECT NombreColumna1, NombreColumna2
FROM NombreTabla
WHERE NombreCampo1=’HOLA MUNDO’;
La query anterior se lee: “Seleccionar solo el NombreColumna1 y NombreColumna2 desde la tabla
NombreTabla, cuando el NombreColumna1 es igual a Hola Mundo”.

Sentencia INSERT.
Permite ingresar filas en una tabla en específico.

48
SINTAXIS INSERT:
 INSERT INTO NombreTabla (NombreColumna1, …, NombreColumnaN) VALUES (ValorColumna1,
…, ValorColumnaN);
En este caso se colocan explícitamente los nombres de las columnas de la tabla.
 INSERT INTO NombreTabla VALUES (ValorColumna1, …, ValorColumnaN);
En este caso NO se colocan explícitamente los nombres de las columnas de la tabla.
Por ejemplo, si se desea ingresar datos a la tabla USUARIO que contiene las siguientes columnas:
Rut que es clave primaria, el nombre y su clave. La sentencia sería de la siguiente forma:
INSERT INTO USUARIO (rut, nombre, clave) VALUES (‘17934333K’,’María José’,’clave123’);
Como se puede observar se deben completar todas las columnas con valores (VALUES). El ingreso
de los registros estará siempre condicionado si la tabla cuenta con restricciones.

Sentencia DELETE.
Permite eliminar los registros que no sean necesarios en una tabla. No se recomienda eliminar
nunca registros de la base de datos a menos que sea estrictamente necesario.
SINTAXIS DELETE:
DELETE FROM NombreTabla;
La sintaxis anterior eliminará todos los registros de la tabla NombreTabla, por lo cual su ejecución
debe ser siempre tomada con precaución.
Es posible eliminar un grupo selectivo de registros de la base de datos, por ejemplo, eliminar
usuarios cuyo nombre sea “Cristobal”. La sentencia sería la siguiente:
DELETE FROM USUARIO
WHERE nombre=‘Cristobal’;

Sentencia UPDATE.
Permite modificar uno o varios datos de una o varias filas de una tabla.
SINTAXIS UPDATE:
UPDATE NombreTabla SET columna=nuevovalor;
Por ejemplo, si se desea cambiar el nombre de “Alfreddo” que fue mal digitado (duplicidad en la
“dd” de su nombre). La sentencia quedaría de la siguiente forma:
UPDATE ALUMNO SET nombre=’Alfredo’ WHERE nombre = ’Alfreddo’;

Transacción de una base de datos.

Una transacción es un conjunto de operaciones que se ejecutan en una base de datos y que son
tratadas como una única unidad lógica por el SGBD. Es decir, una transacción es una o varias

49
sentencias SQL que se ejecutan en una base de datos como una única operación, confirmándose o
deshaciéndose en grupo.
No todas las operaciones SQL son transaccionales. Sólo son transaccionales las operaciones
correspondientes al DML, es decir, sentencias SELECT, INSERT, UPDATE y DELETE
Para confirmar una transacción se utiliza la sentencia COMMIT, al ejecutarla los cambios se escriben
en la base de datos. Para deshacer una transacción se utiliza la sentencia ROLLBACK, al ejecutarla se
deshacen todas las modificaciones realizadas por la transacción en la base de datos, quedando la
base de datos en el mismo estado que antes de iniciarse la transacción.
¿Cómo usar Oracle SQL Developer para poblar y manipular los datos del modelo físico?
A continuación, se mostrará en detalle el uso de las sentencias SQL DML. Se crearán algunas tablas
para insertar, modificar, consultar y eliminar datos con las sentencias INSERT, UPDATE, SELECT y
DELETE. Primero se creará la tabla EMPRESA:
-- Creación tabla EMPRESA
CREATE TABLE EMPRESA (
idempresa NUMBER PRIMARY KEY,
nombreempresa VARCHAR2(30) NOT NULL,
fechacreacion DATE NOT NULL);
La tabla se visualiza de la siguiente forma:

Una vez creada la tabla se ejecutarán las siguientes sentencias para insertar 2 filas en la tabla:
-- Insertar datos en empresa
INSERT INTO EMPRESA VALUES(1,'Empresa 1','01-12-2009');
INSERT INTO EMPRESA VALUES(2,'Empresa 2','24-12-2009');
Al ejecutar las sentencias es mostrado un mensaje que indica que las filas fueron insertadas y al
seleccionar la pestaña Datos se puede ver que los datos fueron almacenados en la tabla.

50
IMPORTANTE: Los valores de las fecha y textos deben ser escritos entre comillas simples.

También, es posible ver los datos insertados a través de la siguiente sentencia:

SELECT * FROM EMPRESA;

Ahora se crearán las tablas REGION, PROVINCIA y COMUNA que están relacionadas entre sí para
posteriormente insertar datos en ellas. La siguiente imagen es parte de un modelo relacional.

Las siguientes sentencias crean las 3 tablas mencionadas.

CREATE TABLE REGION (
idregion NUMBER PRIMARY KEY,
descripcionregion VARCHAR2(30) NOT NULL);
CREATE TABLE PROVINCIA (
idprovincia NUMBER PRIMARY KEY,
descripcionprovincia VARCHAR2(30) NOT NULL,
idregion NUMBER CONSTRAINT FK_IDR_REG NOT NULL REFERENCES REGION(idregion));
CREATE TABLE COMUNA (
idcomuna NUMBER PRIMARY KEY,
descripcioncomuna VARCHAR2(30) NOT NULL,
idprovincia NUMBER CONSTRAINT FK_IDP_PRO REFERENCES PROVINCIA (idprovincia));

51
Al actualizar se pueden ver las tablas en la aplicación:

Al ingresar al detalle de la tabla PROVINCIA y seleccionar la pestaña Modelo se pueden ver las
relaciones entre las 3 tablas creadas.

IMPORTANTE: El nombre de las tablas comienza por ADMIN. que es el nombre del esquema
asociado al usuario de conexión a la base de datos.
Una vez creadas las tablas se procede a poblarlas con datos. Primero se comienza con la tabla
REGION porque no necesita datos que provengan de otra tabla, luego se insertan datos en la tabla
PROVINCIA porque necesita datos de la tabla REGION y finalmente, se insertan datos en la tabla
COMUNA ya que necesita datos de la tabla PROVINCIA.
Será creada una secuencia para la tabla REGION con la finalidad de ingresar números que se
incrementen automáticamente para la columna idregion. La siguiente sentencia crea la secuencia
SEQ_REG que comienza en el 1 y se incrementa en 1.
--Crear secuencia tabla REGION.
CREATE SEQUENCE SEQ_REG
START WITH 1

52
INCREMENT BY 1;
Si se necesita eliminar la secuencia se debe ejecutar la siguiente sentencia:
DROP SEQUENCE SEQ_REG;
Finalmente, serán ingresados 3 filas en la tabla REGION con las sentencias mostradas a continuación:
-- Insertar datos en tabla REGION
INSERT INTO REGION VALUES(SEQ_REG.nextval,'Región de Arica y Parinacota');
INSERT INTO REGION VALUES(SEQ_REG.nextval,'Región de Tarapacá');
INSERT INTO REGION VALUES(SEQ_REG.nextval,'Región de Antofagasta');
Para la columna idregion se asigna SEQ_REG.nextval que significa que insertará el siguiente valor
de la secuencia SEQ_REG. Los datos de la tabla quedarán de la siguiente forma:

Si se desea ordenar los datos por la columna idregion pero en forma descendente se debe
seleccionar el botón Ordenar… y será desplegada una ventana donde se puede seleccionar la
columna por la cual se ordenará y el tipo de ordenamiento (ascendente o descendente).

53
Para el ejemplo, fue seleccionada la columna idregion y el ordenamiento descendente. Al presionar
el botón Aceptar las filas se muestran de la siguiente manera:

Es posible restringir la cantidad de filas que devuelve la sentencia SELECT. Por ejemplo, si se desea
solo ver los datos de la región cuyo idregion es 1 se debe ejecutar la siguiente sentencia:
SELECT * FROM REGION
WHERE idregion = 1;
El resultado sería el siguiente:

54
En la aplicación también se pueden filtrar los datos, para el caso anterior se debe seleccionar la
columna en la opción Filtrar y colocar la condición, para el ejemplo se colocó idregion=1 para que
solo se muestre la fila de la región 1. Es necesario presionar Enter para que se aplique el filtro.

Para insertar datos en la tabla PROVINCIA se creará una secuencia para la columna idprovincia. La
siguiente sentencia crea la secuencia SEQ_PRO que comienza en el 10 y se incrementa en 10.
--Crear secuencia tabla PROVINCIA.
CREATE SEQUENCE SEQ_PRO
START WITH 10
INCREMENT BY 10;
Serán insertadas 2 provincias para la Región de Arica y Parinacota.
-- Insertar datos en tabla PROVINCIA
INSERT INTO PROVINCIA VALUES(SEQ_PRO.nextval,'Provincia Parinacota',1);
INSERT INTO PROVINCIA VALUES(SEQ_PRO.nextval,'Provincia Arica',1);
En la tabla los datos fueron almacenados de la siguiente forma:

Una vez ingresadas las provincias será actualizada la descripción de la provincia 10 con la siguiente
sentencia:
-- Actualizar datos en tabla PROVINCIA
UPDATE PROVINCIA SET descripcionprovincia='Nueva Provincia'
WHERE idprovincia=10;

55
Para el ejemplo, la descripción de la provincia 10 será actualizado a Nueva Provincia.

Si se ejecuta la siguiente sentencia de UPDATE sin el WHERE la descripción de todas las filas de la
tabla PROVINCIA será actualizada a Nueva Provincia.
UPDATE PROVINCIA SET descripcionprovincia='Nueva Provincia';
Si se requiere eliminar la provincia 10 de la tabla PROVINCIA se debe ejecutar la siguiente sentencia:
-- Eliminar datos en tabla PROVINCIA
DELETE FROM PROVINCIA
WHERE idprovincia=10;
Se puede apreciar que la provincia 10 ya no se encuentra en la tabla PROVINCIA.

Finalmente, se insertará una comuna para la provincia 20. En esta ocasión no se usará una secuencia
para insertar datos en la columna idcomuna.
-- Insertar datos en comuna
INSERT INTO COMUNA VALUES(1,'Arica',20);
La fila insertada queda de la siguiente forma:

56
¿Por qué desnormalizamos un modelo normalizado?
Una vez implementado el modelo relacional en el SGBD, no se deben olvidar algunos puntos:
¿El modelo cumple con los requerimientos de negocio en tiempos de respuesta a las consultas
realizadas?
Según las necesidades del negocio, si la cantidad de registros aumenta ¿Los tiempos de respuestas
de la base de datos seguirán siendo eficientes y eficaces?
Para poder asegurar que los tiempos de respuesta de la base de datos siempre sean los esperados
por el usuario hay que considerar los siguientes puntos antes de realizar alguna modificación
estructural en la base de datos:
¿Es el SGBD adecuado para soportar el volumen de datos que debe almacenar la base de datos?
¿El hardware utilizado es el requerido por el SGBD para cumplir con los tiempos de respuesta
requeridos?
¿La configuración de la red de comunicaciones entre los servidores es la adecuada?
¿Es el modelo relacional adecuado para la solución?
¿Las consultas a la base de datos son eficientes?
Si la respuesta a las preguntas anteriores es Sí, se debe considerar desnormalizar el modelo
relacional. La desnormalización es el proceso de procura optimizar el funcionamiento de una base
de datos por medio de agregar datos redundantes. A veces es necesario porque los actuales
sistemas de gestión de bases de datos (SGBD) implementan el modelo relacional de manera
limitada.
Es necesario aclarar que la desnormalización debe realizarse después de que haya existido o se haya
realizado una normalización.
El proceso de desnormalización del modelo es una alternativa para disminuir los tiempos de
respuesta, pero se debe considerar los siguientes riesgos y costos asociados:
1. Redundancia en el modelo, por lo tanto, en algunos casos existe la necesidad de aumentar
el almacenamiento.
2. Perder la integridad de los datos al realizar las tareas de mantención.
3. Asignar más del esfuerzo necesario en tratar de optimizar todo el proceso de negocio.
4. Se debe considerar un mayor esfuerzo en la mantención de los datos.
5. El rendimiento de una base de datos tras la normalización si es adecuado no debe
desnormalizarse.
6. Valoración acerca de qué se prefiere: si una mejor integridad o un mejor rendimiento.

57
 7. Valorar la operatividad en el futuro, puesto que la desnormalización mejora el rendimiento,
pero la estructura dependerá de la aplicación.

¿Cómo podemos desnormalizar?

En términos simples se pueden aplicar las siguientes técnicas para asegurar una mejora en una
consulta:
 Almacenamiento de valores calculados.
 Unión de tablas.
 Separación de tablas.
 Inclusión de valores por temporalidad.
 Creación de tablas.

Almacenamiento de valores calculados.

Cada día se requiere con más frecuencia obtener información de valor para el negocio y esto deriva
en que las bases de datos ahora no sólo son transaccionales, sino que también deben responder a
consultas más elaboradas. Es por eso que cuando existe una consulta de gran demanda y que incluye
cálculos que comprometen gran cantidad de filas de una tabla (promedio, suma, media,
porcentajes, etc.) es recomendable agregar ese campo calculado a la tabla.
Por ejemplo, si se necesita obtener la cantidad de empleados que trabajan en cada departamento
en una empresa. Se puede agregar el campo total_empleados en la tabla DEPARTAMENTO.

La eficiencia de incluir estos cálculos en el modelo está directamente relacionada con la frecuencia
de consulta, ya que aplicar esta estrategia conlleva esfuerzo adicional en otras tareas. Debido a que
los valores deben ser recalculados cada vez que se realiza una actualización sobre los datos
(inserción, actualización y/o eliminación de registros).
Otro ejemplo, es agregar en la tabla MEDICO el campo total_atenciones que guardar la cantidad de
atenciones pertenecientes a cada médico.

58
Unión de tablas.
Otra forma de optimizar una consulta es tener que leer la menor cantidad de tablas y registros
posibles. En el caso de las tablas que tienen relaciones 1:M es recomendable unir las tablas en una
que contenga las columnas de las dos tablas. Se recomienda utilizar esta técnica solo cuando existen
poca cantidad de atributos en la tabla.
En el ejemplo, se unen las columnas de las tablas CATEGORIA y PRODUCTO para dejar solo la tabla
PRODUCTO.

Separación de tablas.
En algunos casos hay tablas que contienen datos que son claramente identificables y que son parte
esencial del negocio. En este caso se puede hacer la separación y asignar las columnas y restricciones
de negocio que correspondan a cada caso.
Por ejemplo, la tabla PERSONA se puede dividir en las tablas CLIENTE y PROSPECTO, las cuales tienen
columnas en común pero su significado es diferente para la empresa u organización.

59
Agregar valores asociados a la temporalidad.
Muchos procesos de negocio necesitan que se realicen comparaciones de datos y/o indicadores en
el tiempo. Es por eso que se debe identificar cuáles son los datos o indicadores y su temporalidad
más demandada en las consultas, para así agregar ese valor como campo en la tabla de destino.
En el ejemplo, se almacenan los productos con los respectivos precios que han tenido a lo largo del
tiempo. Para obtener el precio actual se debe buscar en la tabla PRECIOS cual es el rango de fechas
de inicio y fin más actual que se encuentra almacenado en la tabla.

En cambio, al colocar la columna valor_actual en la tabla PRODUCTO es más rápido encontrar cual
es el precio actual del producto.

60
Creación de tablas.
Finalmente, se pueden crear tablas con las columnas necesarias para realizar una consulta
específica. Generalmente, estas tablas no tienen relación con otras tablas.
En el ejemplo, la siguiente tabla almacena los relatores que realizaron un total de cursos menor al
promedio del año.

Para esta técnica se debe considerar que debe existir un proceso que inserte las filas en dichas
tablas.

61