Guía Estudio Practica 5 SQL

UNIVERSIDAD TECNOLOGICA NACIONAL - FACULTAD REGIONAL MENDOZA
CATEDRA: GESTION DE DATOS - INGENIERIA EN SISTEMAS DE INFORMACION

PROFESOR: María E. STEFANONI – JTP: Higinio A. FACCHINI – Matilde I. CESARI
ENTORNO TEÓRICO, MANUAL DE SQL

SQL es el lenguaje fundamental de los SGBD relacionales.
SQL es un lenguaje declarativo en lo que lo importante es definir qué se desea hacer, por encima
de cómo hacerlo (que es la forma de trabajar de los lenguajes de programación de aplicaciones
como C o Java). Con este lenguaje se pretendía que las instrucciones se pudieran escribir como si
fueran órdenes humanas; es decir, utilizar un lenguaje lo más natural posible. De ahí que se le
considere un lenguaje de cuarta generación.
Se trata de un lenguaje que intenta agrupar todas las funciones que se le pueden pedir a una
base de datos, por lo que es el lenguaje utilizado tanto por administradores como por
programadores o incluso usuarios avanzados
Según la normativa ANSI/ISO cuando se ejecuta SQL, existen los siguientes elementos a tener
en cuenta en todo el entorno involucrado en la ejecución de instrucciones SQL:
1. Un AGENTE SQL. Entendido como cualquier elemento que cause la ejecución de instrucciones
SQL que serán recibidas por un cliente SQL
2. Una IMPLEMENTACIÓN SQL. Se trata de un procesador software capaz de ejecutar las
instrucciones pedidas por el agente SQL. Una implementación está compuesta por:
- Un cliente SQL. Software conectado al agente que funciona como interfaz entre el agente
SQL y el servidor SQL. Sirve para establecer conexiones entre sí mismo y el servidor SQL.
- Un servidor SQL (puede haber varios). El software encargado de manejar los datos a los
que la instrucción SQL lanzada por el agente hace referencia. Es el software que realmente
realiza la instrucción, los datos los devuelve al cliente.
Posibles agentes SQL. posibles modos de ejecución SQL
- EJECUCIÓN DIRECTA. SQL INTERACTIVO Las instrucciones SQL se introducen a través de un cliente
que está directamente conectado al servidor SQL; por lo que las instrucciones se traducen sin
intermediarios y los resultados se muestran en el cliente. Normalmente es un modo de
trabajo incómodo, pero permite tener acceso a todas las capacidades del lenguaje SQL de la
base de datos a la que estamos conectados.
- EJECUCIÓN INCRUSTADA O EMBEBIDA Las instrucciones SQL se colocan como parte del código de
otro lenguaje que se considera anfitrión (C, Java, Pascal, Visual Basic,...). Al compilar el
código se utiliza un precompilador de la propia base de datos para traducir el SQL y conectar
la aplicación resultado con la base de datos a través de un software adaptador (driver) como
JDBC u ODBC por ejemplo.
- EJECUCIÓN A TRAVÉS DE CLIENTES GRÁFICOS Se trata de software que permite conectar a la base de
datos a través de un cliente. El software permite manejar de forma gráfica la base de datos y
las acciones realizadas son traducidas a SQL y enviadas al servidor. Los resultados recibidos
vuelven a ser traducidos de forma gráfica para un manejo más cómodo
- EJECUCIÓN DINÁMICA Se trata de SQL incrustado en módulos especiales que pueden ser
invocados una y otra vez desde distintas aplicaciones.
Guia estudio práctica 5-GD-2019 Página 1

Proceso de las instrucciones SQL

El proceso de una instrucción SQL es el siguiente:
(1) Se analiza la instrucción. Para comprobar la sintaxis de la misma
(2) Si es correcta se valora si los metadatos de la misma son correctos. Se comprueba esto
en el diccionario de datos.
(3) Si es correcta, se optimiza, a fin de consumir los mínimos recursos posibles.
(4) Se ejecuta la sentencia y se muestra el resultado al emisor de la misma.
El código SQL consta de los siguientes elementos:

 COMANDOS. Las distintas instrucciones que se pueden realizar desde SQL
Comando Descripción
SELECT Se trata del comando que permite realizar consultas sobre los datos de la base de
datos. Extrae datos de la base de datos.
A ésta parte del lenguaje se la conoce como DQL (Data Query Language, Lenguaje
de consulta de datos); pero es parte del DML del lenguaje
INSERT, Ingresa nuevas filas, cambia filas existentes y elimina filas de las tablas de la base
UPDATE, MERGE de datos, respectivamente. En conjunto se los conoce como los comandos DML
y DELETE Data Manipulation Language (Lenguaje de manipulación de datos). Modifica filas
(registros) de la base de datos.
CREATE, ALTER, Crea, cambia, y remueve las estructuras de datos de las tablas. En conjunto se los
DROP, RENAME y conoce como los comandos DDL Data Definition Language (Lenguaje de definición
TRUNCATE. de datos). Permiten modificar la estructura de las tablas de la base de datos
COMMIT Instrucciones de control de transacciones (DTL). Administran las modificaciones
ROLLBACK creadas por las instrucciones DML. Lo forman las instrucciones ROLLBACK y
SAVEPOINT COMMIT. Se las considera parte del DML. Los cambios a los datos pueden ser
agrupados en transacciones lógicas.
GRANT Otorga o quita derechos de acceso a la base de datos de Oracle y a sus
REVOKE estructuras. En conjunto se los conoce como los comandos DCL Data Control
Language (Lenguaje de control de datos). Administran los derechos y restricciones
de los usuarios
 CLÁUSULAS. Son palabras especiales que permiten modificar el funcionamiento de un comando
(WHERE, ORDER BY,...)
 OPERADORES. Permiten crear expresiones complejas. Pueden ser aritméticos (+,-,*,/,...)
lógicos (>, <, !=,<>, AND, OR,...)
 FUNCIONES. Para conseguir valores complejos (SUM(), DATE(),...)
 LITERALES. Valores concretos para las consultas: números, textos, caracteres,...
Ejemplos: 2, 12.34, 'Avda Cardenal Cisneros'
 METADATOS. Obtenidos de la propia base de datos
 En SQL NO SE DISTINGUE entre MAYÚSCULAS Y MINÚSCULAS.
 Las instrucciones FINALIZAN con el signo de PUNTO Y COMA
 Cualquier comando SQL (SELECT, INSERT,...) puede ser partidos por ESPACIOS O SALTOS de
línea antes de finalizar la instrucción
 Se pueden TABULAR líneas para facilitar la lectura si fuera necesario
 Los COMENTARIOS en el código SQL comienzan por /* y terminan por */ (excepto en algunos
SGBD)

Pasos para implementar una base de datos1:
PASO Descripción
Definir en el disco duro, el área física que contendrá las tablas de la base de datos.
1
Sentencia SQL --> CREATE DATABASE
Crear las diferentes tablas de la base de dato.
2
Sentencia SQL --> CREATE TABLE
Insertar las filas de las diferentes tablas, sin violar la integridad de datos.
3
Sentencia SQL --> INSERT INTO
Actualizar los datos que cambien con el tiempo en las diferentes tablas.
4
Sentencia SQL --> UPDATE
Eliminar las filas que ya no se requieran en las diferentes tablas.
5
Sentencia SQL --> DELETE
Realizar las consultas deseadas a las tablas de la base de datos a través de la
6
poderosa sentencia de consultas del SQL, llamada SELECT
Dar nombre a las consultas. Elaboradas en el paso No.6 cuando se requiera ocultar
7 el diseño y columnas de las tablas a través de la creación de vistas lógicas.
Sentencia SQL ----> CREATE VIEW
El DDL es la parte del lenguaje SQL que realiza la función de definición de datos del
SGBD. Fundamentalmente se encarga de la creación, modificación y eliminación de los
objetos de la base de datos (es decir de los metadatos). Por supuesto es el encargado
de la creación de las tablas.
Cada usuario de una base de datos posee un esquema. El esquema suele tener el mismo
nombre que el usuario y sirve para almacenar los objetos de esquema, es decir los
objetos que posee el usuario.
Esos objetos pueden ser: tablas, vistas, índices y otras objetos relacionados con la
definición de la base de datos. Los objetos son manipulados y creados por los usuarios.
En principio sólo los administradores y los usuarios propietarios pueden acceder a cada
objeto, salvo que se modifiquen los privilegios del objeto para permitir el acceso a otros
usuarios.
Las instrucciones DDL generan acciones que no se pueden deshacer (salvo que
dispongamos de alguna copia de seguridad).
Según los estándares actuales, una base de datos es un conjunto de objetos pensados
para gestionar datos. Estos objetos están contenidos en esquemas, los esquemas suelen
estar asociados al perfil de un usuario en particular.
En el estándar SQL existe el concepto de catálogo que sirve para almacenar esquemas.
Así el nombre completo de un objeto vendría dado por: catálogo.esquema.objeto
Si no se indica el catálogo se toma el catálogo por defecto. Si no se indica el esquema se
entiende que el objeto está en el esquema actual. En Oracle, cuando se crea un usuario,
se crea un esquema cuyo nombre es el del usuario.
1
Elaborado a partir del material base de: Alvaro E. García Manual Práctico de SQL, ORIENTADO A SQL 7.0
(noviembre de 2003); y Juan Ramón López Rodríguez. 2.4.-ElLenguajeSQL. Licenciatura en Documentación: Bases de
datos documentais Curso 2011 – 2012
Ejemplo a utilizar
Antes de abordar la descripción del lenguaje SQL, estableceremos el ejemplo de partida
que utilizaremos a lo largo de la explicación de la instrucción SELECT.
Se trata del esquema lógico - relativo a la gestión de una empresa – que habíamos
obtenido al analizar la transformación desde el modelo ER al modelo relacional.
Las relaciones, desde el punto de vista de SQL, deben ser consideradas como tablas;
asumiremos que, como tales, contienen los siguientes datos en un momento dado:
Departamentos
Empleados
Proyectos
LocalidadDept
TrabajaEn

 CREACIÓN DE BASES DE DATOS

Esta es una tarea administrativa por ahora sólo se comenta de forma simple. Crear la
base de datos implica indicar los archivos y ubicaciones que se utilizarán para la misma,
además de otras indicaciones técnicas y administrativas que no se comentarán en este
tema. Lógicamente sólo es posible crear una base de datos si se tienen privilegios DBA
(DataBase Administrator) (SYSDBA en el caso de Oracle).
El comando SQL de creación de una base de datos es CREATE DATABASE. Este
comando crea una base de datos con el nombre que se indique
Sentencia SQL CREATE DATABASE
SINTAXIS:
create database nombre_basededatos ON PRIMARY (
name = nombre_basededatos _data,
filename = 'c:\BDTRANSITO.mdf', /*Dirección donde se crea*/
size = 5mb, /*Tamaño de la base de datos*/
maxsize = 10mb, /*Tamaño de maximo de la base de datos*/
filegrowth = 1 mb /*crecimiento de la base de datos*/
)
Crea una BD, denominada Empleados, que contenga información relativa a los
empleados de una EMPRESA y sus tareas o proyectos realizados.
Vamos a crear una DB desde SQL, con el MySQL Query Browser
Vamos al menú File >> New Script Tab. Escribimos:
Ejemplo parámetros de Oracle:

CREATE DATABASE prueba
LOGFILE prueba.log
MAXLOGFILES 25
MAXINSTANCES 10
ARCHIVELOG
CHARACTER SET WIN1214
NATIONAL CHARACTER SET UTF8
DATAFILE prueba1.dbf AUTOEXTEND ON MAXSIZE 500MB;
Tipo de archivo Extensión de nombre de archivo recomendada

Archivo de datos principal .mdf
Archivo de datos secundario .ndf
Archivo de registro de transacciones .ldf
En el ejemplo que se acaba de presentar se crea un archivo principal de extensión mdf de
tamaño inicial de 5 MB, cuando este espacio se agote, este se expandirá en 1 MB más para tener
espacio libre y meter más registros o tablas y cuando se agote nuevamente el archivo físico de
1MB, éste se expandirá en 1 MB nuevamente y así en lo sucesivo hasta alcanzar el máximo 10
MB ya de ahí no crecerá más.

 CREACIÓN DE TABLAS
Sentencia CREATE
Dentro del Lenguaje de Definición (DL) del SQL, la sentencia CREATE permiten la
definición o creación de muchos objetos de la base de datos tales como: tablas
(esquemas), índices, vistas, dominios, ligaduras de integridad y procedimientos.
En esta oportunidad veremos las sentencias correspondientes a la creación de los
esquemas o lo que es lo mismo las tablas que contendrán los datos de la base de datos.
La sentencia CREATE TABLE. Define el nombre de la tabla, las columnas con su tipo de
datos, las ligaduras de intengridad que vigilan el valor que se guarde como dato en las
columnas o atributos sean llaves o no.
CREATE TABLE Proyectos ( nombre VARCHAR(50) );
Sólo se podrá crear la tabla si el usuario posee los permisos necesarios para ello. Si la
tabla pertenece a otro esquema (suponiendo que el usuario tenga permiso para grabar
tablas en ese otro esquema), se antepone al nombre de la tabla, el nombre del
esquema: CREATE TABLE otroUsuario.Proyectos (nombre VARCHAR(50));
Se puede indicar un valor por defecto para el atributo mediante la cláusula DEFAULT:
CREATE TABLE Proyectos (
nombre VARCHAR(50),
localidad VARCHAR(30) DEFAULT ‘Ciudad’);
De este modo si añadimos un proyecto y no indicamos localidad, se tomará Ciudad como
localidad de dicho Proyecto.
Sintaxis completa:
CREATE TABLE nombre_tabla (
campo1 tipo dato [NULL/NOT NULL] | CHECK (expresiónLógica) |
[DEFAULT expresiónConstante],
campo2 tipo dato [NULL/NOT NULL] | CHECK (expresiónLógica) |
[DEFAULT expresiónConstante ],
campo-N,
PRIMARY KEY(campo_llave),
FOREIGN KEY (campo_llave) REFERENCES tabla2 (campo_llave-tabla2)
)
- nombre_tabla se refiere a un nombre de tabla concreto
Deben cumplir las siguientes reglas (reglas de Oracle, en otros SGBD podrían cambiar):
- Deben comenzar con una letra
- No deben tener más de 30 caracteres
- Sólo se permiten utilizar letras del alfabeto (inglés), números o el signo de subrayado
(también el signo $ y #, pero esos se utilizan de manera especial por lo que no son
recomendados)

- No puede haber dos tablas con el mismo nombre para el 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
sólo en algunas bases de datos), entonces se suele entrecomillar con comillas dobles. En
el 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
“FACTURAS” y “Facturas”)
- [ ] (corchetes). Los corchetes sirven para encerrar texto que no es obligatorio en el comando,
es decir para indicar una parte opcional.
- | (barra vertical). Este símbolo (|), la barra vertical, indica opción. Las palabras separadas
con este signo indican que se debe elegir una de entre todas las palabras.
- ... (puntos suspensivos) Indica que se puede repetir el texto anterior en el comando
continuamente (significaría, y así sucesivamente)
- {} (llaves) Las llaves sirven para indicar opciones mutuamente exclusivas pero obligatorias.
Es decir, opciones de las que sólo se puede elegir una opción, pero de las que es obligado
elegir una
Tipos de datos
A la hora de crear tablas, hay que indicar el tipo de datos de cada campo. Necesitamos
pues conocer los distintos tipos de datos
Descripción Tipos Estándar SQL Oracle SQL
Texto
Texto de anchura fija CHARACTER(n) CHAR(n) CHAR(n)
Texto de anchura variable CHARACTER VARYING(n) VARCHAR (n) VARCHAR2(n)
Texto de anchura fija para NATIONAL CHARACTER(n) NATIONAL NCHAR(n)
caracteres nacionales CHAR(n) NCHAR(n)
Texto de anchura variable NATIONAL CHARACTER VARYING(n) NVARCHAR2(n)
para caracteres nacionales NATIONAL CHAR VARYING(n)
NCHAR VARYING(n)
Números
Enteros pequeños (2 bytes) SMALLINT
Enteros normales (4 bytes) INTEGER INT
Enteros largos (8 bytes) BIGINT
(en realidad no es estándar, pero es muy
utilizado en muchas bases de datos)
Enteros NUMBER(n)
precisión
decimal
Decimal de coma variable FLOAT NUMBER
DOUBLE
DOUBLE PRECISSION
REAL
Decimal de coma fija NUMERIC(m,d) DECIMAL(m,d) NUMBER(m,d)
Fechas
Fechas DATE DATE
Fecha y hora TIMESTAMP TIMESTAMP
Intervalos INTERVAL INTERVAL

Descripción Tipos Estándar SQL Oracle SQL

Booleanos y binarios
Lógicos BOOLEAN BOOL
Binarios BIT
BIT VARYING(n)
VARBIT(n)
Datos de gran tamaño
Texto gran longitud CHARACTER LARGE OBJECT CLOB LONG (en desuso) CLOB
Binario de gran longitud BINARY LARGE OBJECT BLOB RAW (en desuso) LONG
RAW (en desuso) BLOB
LOS TIPOS ORACLE.
- textos
 VARCHAR . Para textos de longitud variable. Su tamaño depende de la base de datos (en
Oracle es de 4000). En Oracle se llama VARCHAR2, pero es posible seguir utilizando
VARCHAR.
 CHAR. Para textos de longitud fija (en Oracle hasta 2000 caracteres).
 NCHAR. Para el almacenamiento de caracteres nacionales de texto fijo
 NVARCHAR. Para el almacenamiento de caracteres nacionales de longitud variable. En
Oracle se llama NVARCHAR2.
En todos estos tipos se indican los tamaños entre paréntesis tras el nombre del tipo. Conviene
poner suficiente espacio para almacenar los valores. En el caso de los VARCHAR2, no se
malgasta espacio por poner más espacio del deseado ya que si el texto es más pequeño que
el tamaño indicado, el resto del espacio se ocupa.
- números
En Oracle, el tipo NUMBER es un formato versátil que permite representar todo tipo de
números. Su rango recoge números de entre 10-130 y 9,99999999999 * 10128. Fuera de estos
rangos Oracle devuelve un error. Los números decimales (números de coma fija) se indican
con NUMBER(p,s), donde p es la precisión máxima y s es la escala (número de decimales a
la derecha de la coma). Por ejemplo, NUMBER (8,3) indica que se representan números de
ocho cifras de precisión y tres decimales. Los decimales en Oracle se presenta con el punto y
no con la coma. Para números enteros se indica NUMBER(p) donde p es el número de
dígitos. Eso es equivalente a NUMBER(p,0). Para números de coma flotante (equivalentes a
los float o double de muchos lenguajes de programación) simplemente se indica el texto
NUMBER sin precisión ni escala.
- precisión y escala
La cuestión de la precisión y la escala es compleja. Para entenderla mejor, se muestran estos
ejemplos:
En definitiva, la precisión debe incluir todos los dígitos del número (puede llegar hasta 38
dígitos). La escala sólo indica los decimales que se respetarán del número, pero si es negativa
indica ceros a la izquierda del decimal.

- Fechas y horas
 DATE. El tipo DATE permite almacenar fechas. Las fechas se pueden escribir en formato
día, mes y año entre comillas. El separador puede ser una barra de dividir, un guión y casi
cualquier símbolo. Para almacenar la fecha actual la mayoría de bases de datos
proporcionan funciones (como SYSDATE en Oracle) que devuelven ese valor. Las fechas
no se pueden manejar directamente, normalmente se usan funciones de conversión. En el
caso de Oracle se suele usar TO_DATE (que se detallará en el tema siguiente). Ejemplo:
TO_DATE(‘3/5/2007’)
 TIMESTAMP. Es una extensión del anterior, almacena valores de día, mes y año, junto
con hora, minuto y segundos (incluso con decimales). Con lo que representa un instante
concreto en el tiempo. Un ejemplo de TIMESTAMP sería ‘2/2/2004 18:34:23,34521’. En
este caso si el formato de fecha y hora del sistema está pensado para el idioma español,
el separador decimal será la coma (y no el punto).
- Intervalos
Sirven para almacenar intervalos de tiempo (no fechas, sino una suma de elementos de
tiempo). En el caso de Oracle son:
 INTERVAL YEAR TO MONTH. Este tipo de datos almacena años y meses. Tras la palabra
YEAR se puede indicar la precisión de los años (cifras del año), por defecto es de dos Para
los intervalos de año a mes los valores se pueden indicar de estas formas:
/* 123 años y seis meses */
INTERVAL '123-6' YEAR TO MONTH
/* 123 años */
INTERVAL '123' YEAR TO MONTH
/* 6 meses */
INTERVAL '6' MONTH TO MONTH
INTERVAL DAY TO SECOND
Representa intervalos de tiempo que expresan días, horas, minutos y segundos. Se puede
indicar la precisión tras el texto DAY y el número de decimales de los segundos tras el
texto SECOND.
Ejemplos:
/* 4 días 10 horas 12 minutos y 7 con 352 segundos */ /*12 minutos*/
INTERVAL '4 10:12:7,352' DAY TO SECOND(3) INTERVAL '12' MINUTE
/* 4 días 10 horas 12 minutos */ /*30 segundos */
INTERVAL '4 10:12' DAY TO MINUTE INTERVAL '30' SECOND
/* 4 días 10 horas */ /*8 horas y 50 minutos */
INTERVAL '4 10' DAY TO HOUR INTERVAL '8:50’ HOUR TO MINUTE;
/* 4 días*/ /*7 minutos 6 segundos*/
INTERVAL '4' DAY INTERVAL '7:06' MINUTE TO SECOND;
/*10 horas*/ /*8 horas 7 minutos 6 segundos*/
INTERVAL '10' HOUR INTERVAL '8:07:06' HOUR TO SECOND;
/*25 horas*/
INTERVAL '253' HOUR
- Datos de gran tamaño

Son tipos pensados para almacenar datos de tamaño muy grande. No pueden poseer
índices ni ser parte de claves.
 CLOB. Utilizado para almacenar datos de texto de gran tamaño (hasta 4 GB de texto)
 BLOB. Utilizado para guardar datos binarios de hasta 4 GB de tamaño

Ligaduras
Esto de las ligaduras es muy importante que le presenten atención. Ayuda a que dejes la
vigilancia de la entrada de datos al DBMS y no al que programa la aplicación que a veces
puede darse que no haga tal validación en la entrada de los datos.
Esto tiene la ventaja de ahorrar líneas de códigos en los programas y no te que se
implementan en la sentencia SQL CREATE TABLE .
Tipo: INTEGRIDAD DE DOMINIO O COLUMNA
Especifica un conjunto de valores que son válidos a ingresar sobre una columna específica para una tabla de la base de
datos . Esta integridad se verifica a través de una la validación de los valores de datos que se ingresan y el tipo de los
datos a introducir (numérico, alfanumérico, alfabético, etc.).
Tipos de
Descripción Cláusula SQL
Restricción
DEFAULT
Por ejemplo, sí las reglas del negocio dicen que no se
Esta restricción asigna un valor específico a contratan a menores de edad, en la columna EDAD en
una columna cuando el valor para ello no haya la tabla EMPLEADO se restringe a que si una edad para
Por Defecto sido explícitamente proporcionado para tal un empleado que ingresa no es señalada
columna en una sentencia “INSERT” o de explícitamente, el DBMS asigne 18 que es la mayoría
adición de un nuevo registro en la tabla. de edad.
CREATE TABLE EMPLEADO (ID_EMPL int Primary KEY,
EDAD int not null default 18)
CHECK
CREATE TABLE EMPLEADO ( ID INT PRIMARY KEY,
Por Específica los valores de datos que el DBMS EDAD INT DEFAULT 18, SEXO VARCHAR(1) CHECK (
Validación acepta le sean ingresados para una columna. SEXO IN (‘F’,’M’) ) )
Por ejemplo, la columna SEXO, solo permitirá el ingreso
del carácter F o M.
REFERENCES
CREATE TABLE JOBS (job_id int primary key not null,
func_id int unique)
Especifica los valores de datos que son CREATE TABLE EMPLEADO ( ID INT PRIMARY KEY,
Por aceptables para actualizar una columna y que EDAD INT DEFAULT 18, SEXO VARCHAR(1) CHECK (
Referencia están basados en valores de datos localizados SEXO IN (‘F’,’M’) ) , NO_FUNC int REFERENCES
en una columna de otra tabla. jobs(func_id))
El valor de lo que entre en la columna NO_FUNC en la
tabla EMPLEADO deberá ser uno de los valores
contenido en la columna FUNC_ID en la Tabla JOBS.
Tipo: INTEGRIDAD DE ENTIDAD O TABLA

Específica que en una tabla o entidad , todas sus filas tenga un identificador único que diferencie a una fila de otra y
también que se establezcan columnas cuyo contenido es un valor único que las hace llaves candidatas para un futuro
como por ejemplo: número de cédula mail. , número de seguro social o cuenta de e-
Tipos de
Restricción
Este tipo de restricción se aplica
a todas las filas permitiendo que PRIMARY KEY
exista un CREATE TABLE CLIENTE (NUMCLI INT not
identificador, que se conoce como llave NOMCLI char(30) not null, DIRCLI char(30), FAX INT,
primaria y que se asegura que los E_MAIL CHAR(30) UNIQUE not null, SALD_0_30 DECIMAL
introduzcan valores (10,2), SALD_31_60 DECIMAL (10,2), SALD_61_90
Por Llave
asegura que se cree un índice para DECIMAL (10,2), primary key (NUMCLI) )
Primaria
mejorar el desempeño. Los valores En este ejemplo, NUMCLI corresponderá a
nulos no están permitidos para este tipo ser la llave primaria de la tabla CLIENTE.
de restricción. UNIQUE
Con esta restricción se previene la CREATE TABLE CLIENTE (NUMCLI INT not
duplicación de valores en columnas

Tipo: INTEGRIDAD DE ENTIDAD O TABLA

Específica que en una tabla o entidad , todas sus filas tenga un identificador único que diferencie a una fila de otra y
también que se establezcan columnas cuyo contenido es un valor único que las hace llaves candidatas para un futuro
como por ejemplo: número de cédula mail. , número de seguro social o cuenta de e-
Tipos de
Restricción
que tienen valor único y que no son
llave
NOMCLI char(30) not null, DIRCLI char(30), FAX INT,
primaria pero que pueden ser una llave
E_MAIL CHAR(30) UNIQUE not
alternativa o candidata para el
Por Valor null, SALD_0_30 DECIMAL (10,2), SALD_31_60 DECIMAL
Unico (10,2), SALD_61_90
futuro. Asegura que
DECIMAL (10,2), primary key (NUMCLI) )
se cree (Por parte del
En este ejemplo, E_MAIL correponderá a
DBMS) un índice para mejorar el
desempeño. Y al igual que las llaves
ser una columna de valores único en la tabla CLIENTE
primarias, no se le está permitido que
se introduzcan valores nulos.
Tipo: INTEGRIDAD REFERENCIAL

La Integridad Referencial asegura que las relaciones que existe entre llave primaria (en la tabla referenciada) y la llave
foránea (en las tablas referenciantes) serán siempre mantenidas. Una fila o registro en la tabla referenciada (tabla donde
reside la llave primaria) no puede ser borrada o su llave primaria cambiada si existe una fila o registro con una llave
foránea (en la tabla referenciante) que se refiere a esa llave primaria.
Tipos de
Restricción
FOREIGN KEY
CREATE TABLE PEDIDO (NUMPED INT not
null PRIMARY KEY,
NUMCLI INT not null, FECHA_PED
En esta restricción se define una DATETIME,
columna o combinación de columnas en TOT_DESC DECIMAL (10,2),
Por Llave
las cuales su valor debe corresponder al FOREIGN KEY (NUMCLI) REFERENCES
Foránea
valor de la llave primaria en la misma u CLIENTE(NUMCLI) )
en otra tabla. En este ejemplo de la creación de la tabla PEDIDO, la
columna NUMCLI correponderá a ser la llave foránea que hace
referecia a la llave primaria NUMCLI (no necesariamente
deben llamarse igual las columnas pero deben tener igual tipo
de datos) en la tabla CLIENTE
Dominios
En Oracle se echa de menos una instrucción que forma parte del estándar SQL y que
permite crear dominios. Sin embargo en SQL estándar sí hay esa posibilidad y de hecho
es muy interesante. Se trata de CREATE DOMAIN:
Ejemplo:
CREATE DOMAIN Tdireccion AS VARCHAR(3);
Gracias a esa instrucción podemos crear la siguiente tabla:
CREATE TABLE Empleado(
rut SMALLINT, nombreP VARCHAR(30), apellido VARCHAR(30),
direccion Tdireccion
)

Como se observa en la sintaxis, se puede indicar un valor por defecto al dominio e

incluso establecer algunas restricciones.
En el caso de Oracle se puede utilizar la instrucción CREATE TYPE, aunque no es
sinónimo de ésta. De hecho CREATE TYPE es una instrucción objeto-relacional y permite
crear tipos avanzados de datos (que no es lo mismo que un dominio).
A continuación se muestran las sentencias CREATE TABLE que crean las tablas de la
Base de Datos “bdempleados”, de la cual ya se creo en MySQL al principio de esta
guía.
- Ingresamos al Explorador de MySQL y creamos un nuevo srcip
Es muy importante el orden en que se crean las tablas. Se debe a que no debe violarse
la referencia cruzada entre las ligaduras de integridad del tipo referencial (es decir llave
primaria con foráneas). Por ejemplo no puede crear la tabla de EMPLEADOS primero que la
tabla de DEPARTAMENTOS, pues la tabla de EMPLEADOS hace referencia a DEPARTAMENTOS.
Primero crear las tablas que solo tienen llave primaria y luego las tablas que incluyen
llaves foráneas.
- Creación de Tabla (Seleccionar la base de dato de MySQL a usar)
CREATE TABLE departamentos ( CREATE TABLE localidadDept (

NumDept VARCHAR(3), NumDept VARCHAR(3),
NomDept VARCHAR(10), Loc VARCHAR(8)
FechaIniGerente VARCHAR(10), PRIMARY KEY (NumDept, Loc),
PRIMARY KEY(NumDept) FOREIGN KEY (NumDept) REFERENCES
); departamentos (NumDept)
);
CREATE TABLE empleados (
NSS INTEGER [NOT NULL], CREATE TABLE proyectos (
NPila VARCHAR(7), Numero VARCHAR(2) ,
Ap1 VARCHAR(5), Nombre VARCHAR(16),
Ap2 VARCHAR(6), Localidad VARCHAR(8),
Sexo VARCHAR(1), NumDept VARCHAR(3)
Direccion VARCHAR(13), PRIMARY KEY(Numero),
Fnac VARCHAR(10), FOREIGN KEY (Numero) REFERENCES
NSSsupervisor INTEGER departamentos (NumDept)
NumDept VARCHAR(3) );
PRIMARY KEY(NSS),
FOREIGN KEY (NumDept) REFERENCES CREATE TABLE trabajaEn (
departamentos (NSS) NSS INTEGER,
); Numero VARCHAR(2) ,
Horas NUMBER(*,0)
PRIMARY KEY(NSS, Numero),
FOREIGN KEY (NSS) REFERENCES empleados
(NSS),
FOREIGN KEY (Numero) REFERENCES
proyectos (Numero)
);

 ELIMINACIÓN DE TABLAS:
La sentencia para eliminar una tabla y por ende todo los objetos asociados con esa tabla
como: las vistas, disparadores, etc., DROP TABLE, donde r es el nombre de una tabla
existente.
Al borrar una tabla:
 Desaparecen todos los datos
 Cualquier vista y sinónimo referente a la tabla seguirá existiendo, pero ya no
funcionará (conviene eliminarlos)
 Las transacciones pendientes son aceptadas (COMMIT), en aquellas bases de datos
que tengan la posibilidad de utilizar transacciones.
 Lógicamente, sólo se pueden eliminar las tablas sobre las que tenemos permiso de
borrado.
Normalmente, el borrado de una tabla es irreversible, y no hay ninguna petición de
confirmación, por lo que conviene ser muy cuidadoso con esta operación.
DROP TABLE r
Por ejemplo si deseamos eliminar a la tabla LocalidadDpt, revisemos haber si esta ya
existe, de la siguiente manera
SELECT * FROM LocalidadDpt
Posteriormente una vez veriifcada que la tabla existe, se procede a borrar la tabla,
escribiendo lo siguiente en la interface de consultas del SQL:
DROP TABLE LocalidadDpt
 MODIFICAR TABLAS
Después que una tabla ha sido utilizada durante algún tiempo, los usuarios suelen
descubrir que desean almacenar información adicional con respecto a las tablas. Por
ejemplo en la base de datos EMPLEADOS, se podría desear:
- Añadir el nombre y número de una persona de contacto a cada fila de la tabla EMPLEADOS para
contactar a los empleados.
- Añadir una columna de punto de re orden mínimo en la tabla PROYECTO, para que la base de
datos pueda alertar automáticamente cuando la cantidad de presupuesto asignado a un
proyecto en particular esta por debajo de lo optimo para su viabilidad.
Por lo general, esta sentencia ALTER TABLE se utiliza sobre tablas que ya poseen desde
cientos a miles de filas por ser tablas de un sistemas de Base de Datos que ya esta en
producción. Los cambios que se pueden realizar con la sentencia SQL ALTER TABLE son
(ver ejemplo con la figura) :
Tabla para ejemplos de sentencia ALTER TABLE.

(1) Cambiar de nombre a una tabla. De forma estándar (SQL estándar) se hace:
(2) Borrar contenido de tablas. Oracle dispone de una orden no estándar para
eliminar definitivamente los datos de una tabla; es la orden TRUNCATE TABLE
seguida del nombre de la tabla a borrar. Hace que se elimine el contenido de la tabla,
pero no la estructura de la tabla en sí. Incluso borra del archivo de datos el espacio
ocupado por la tabla.
(3) Añadir columnas. Añadir una definición de la columna de una tabla. Puede crearse
con valores nulos o valores
Permite añadir nuevas columnas a la tabla. Se deben indicar su tipo de datos y sus
propiedades si es necesario (al estilo de CREATE TABLE). Las nuevas columnas se
añaden al final, no se puede indicar otra posición (hay que recordar que el orden de
las columnas no importa). Ejemplo:
ALTER TABLE T1 ADD (a6 VARCHAR(30) NULL); ALTER TABLE facturas ADD (fecha DATE);
Muchas bases de datos (pero no Oracle) requieren escribir la palabra COLUMN tras
la palabra ADD. Normalmente suele ser opcional
(4) Borrar columnas. Eliminar una columna de la tabla. Pero antes de su eliminación
deben ser eliminados por ALTER TABLE todas las restricciones que estén definidas
sobre esta columna.
Elimina la columna indicada de manera irreversible e incluyendo los datos que

contenía. No se puede eliminar la única columna de una tabla que sólo tiene esa
columna (habrá que usar DROP TABLE). Ejemplo:
ALTER TABLE T1 DROP (a4); ALTER TABLE facturas DROP (fecha);
Al igual que en el caso anterior, en SQL estándar se puede escribir el texto COLUMN
tras la palabra DROP.Eliminar la definición de: LLAVE PRIMARIA, FORÁNEA o
RESTRICCIONES DE LIGADURAS de integridad (check), existentes para una tabla. Esta
acción no elimina la a la columna con sus valores, ella permanece tal cual como esta,
solo se elimina su definición. Este procedimiento varia de DBMS, con SQL SEVER,
Primero se debe averiguar el nombre de la restricción o ligadura de integridad
(CONSTRAINT) eliminar se ejecuta el procedimiento almacenado SP_HELP
nombre_de_Tabla y en el resultado se busca en la columna constraint_name a la
derecha de constraint_type para saber el nombre que el DBMS le puso a la
restricción de llave primaria y luego se ejecuta la sentencia ALTER TABLE con el
nombre de la definición de llave primaria a eliminar.
Ejemplo: ALTER TABLE T1 DROP CONSTRAINT PK__T1__numeroqueasignaelDBMS
Esto elimina cualquiera ligadura de integridad. Para verificar al ejecutar nuevamente
SP_HELP nombre_de_Tabla, en el resultado ya no sale en constraint_type el nombre
de la llave primaria.

(5) Modificar columna. Permite cambiar el tipo de datos y propiedades de una

determinada columna. Sintaxis:
Los cambios que se permiten son (en Oracle):

- Incrementar precisión o anchura de los tipos de datos
- Sólo se puede reducir la anchura si la anchura máxima de un campo si esa columna posee
nulos en todos los registros, o todos los valores son tan pequeños como la nueva anchura
o no hay registros
- Se puede pasar de CHAR a VARCHAR2 y viceversa (si no se modifica la anchura)
- Se puede pasar de DATE a TIMESTAMP y viceversa
- Cualquier otro cambio sólo es posible si la tabla está vacía
Ejemplo: ALTER TABLE facturas MODIFY(fecha TIMESTAMP);
En el caso de SQL estándar en lugar de MODIFY se emplea ALTER (que además
opcionalmente puede ir seguida de COLUMN).
Por ejemplo: ALTER TABLE facturas ALTER COLUMN fecha TIMESTAMP;
(6) Renombrar columna. Esto permite cambiar el nombre de una columna. Sintaxis
Ejemplo: ALTER TABLE facturas RENAME COLUMN fecha TO fechaYhora;

(7) Valor por defecto. A cada columna se le puede asignar un valor por defecto durante
su creación mediante la propiedad DEFAULT. Se puede poner esta propiedad
durante la creación o modificación de la tabla, añadiendo la palabra DEFAULT tras el
tipo de datos del campo y colocando detrás el valor que se desea por defecto.
Ejemplo: CREATE TABLE articulo (
cod NUMBER(7), nombre VARCHAR2(25), precio NUMBER(11,2) DEFAULT 3.5);
La palabra DEFAULT se puede añadir durante la creación o la modificación de la tabla
(comando ALTER TABLE)
(8) Definir una llave primaria para una tabla. La columna(s) a la cual se le dará esta
responsabilidad debe contener previamente valores únicos por fila.
Ejemplo: ALTER TABLE T1 ADD PRIMARY KEY (a1,a2);
(9) Definir una nueva llave foránea para una tabla. La columna a definir como llave
foránea debe contener previamente valores que corresponden a la llave primaria
de otra tabla. Es similar al descrito en llave primaria, solo que la palabra clave
reservada es ADD FOREIGN KEY .
(10) Se puede habilitar o inhabilitar los disparadores (trigger) en una tabla.
ALTER TABLE nombre_de_la_tabla ENABLE TRIGGER nombre_de_trigger
ALTER TABLE nombre_de_la_tabla DISABLE TRIGGER nombre_de_trigger
La persona que puede realizar esta operación de alterar la tabla puede ser: el DBA o
el creador de la tabla, u otra persona que el creador o DBA haya autorizado.
Para la última situación en que a una persona se le otorga el permiso en la
operación, el usuario, debe calificar el nombre de la tabla con el nombre de su
creador por delante y alterar la definición de la tabla de otro usuario, por ejemplo:
ALTER TABLE nombredueño.nombretabla

El DML (Data Manipulation Language) lo forman las instrucciones capaces de

modificar los datos de las tablas. Al conjunto de instrucciones DML que se ejecutan
consecutivamente, se las llama transacciones y se pueden anular todas ellas o aceptar,
ya que una instrucción DML no es realmente efectuada hasta que no se acepta
(COMMIT).
INSERCIÓN DE DATOS
La adición de datos a una tabla se realiza mediante la instrucción INSERT. Su sintaxis
fundamental es:
La tabla representa la tabla a la que queremos añadir el registro y los valores que
siguen a VALUES son los valores que damos a los distintos campos del registro. Si no se
especifica la lista de campos, la lista de valores debe seguir el orden de las columnas
según fueron creados (es el orden de columnas según las devuelve el comando
DESCRIBE).
La lista de campos a rellenar se indica si no queremos rellenar todos los campos. Los
campos no rellenados explícitamente con la orden INSERT, se rellenan con su valor por
defecto (DEFAULT) o bien con NULL si no se indicó valor alguno. Si algún campo tiene
restricción de obligatoriedad (NOT NULL), ocurrirá un error si no rellenamos el campo
con algún valor.
Por ejemplo, supongamos que tenemos una tabla de empleados cuyos campos son: dni,
nombreP, apellido1, apellido2, Sexo y dirección; supongamos que ese es el orden de
creación de los campos de esa tabla y que la localidad tiene como valor por defecto
Masculino y la dirección no tiene valor por defecto. En ese caso estas dos instrucciones
son equivalentes:
INSERT INTO empleados VALUES( '11111111','Pedro','Gutiérrez',
'Masculino',DEFAULT,NULL);
INSERT INTO empleados (dni,nombreP,apellido1,apellido2)
VALUES('11111111','Pedro','Gutiérrez', ' Masculino ');
Son equivalentes puestos que en la segunda instrucción los campos no indicados se
rellenan con su valor por defecto y la dirección no tiene valor por defecto. La palabra
DEFAULT fuerza a utilizar ese valor por defecto.
El uso de los distintos tipos de datos debe de cumplir los requisitos ya comentados en
apartados anteriores.

Agreguemos instancias a nuestras tablas creadas desde el SQLDeveloper en la

base de datos de Mysql
Tabla empleados
--Fila 1
INSERT INTO Empleados (NSS, NPILA, AP1, AP2, SEXO, DIRECCION, FNAC, NUMDEPT,
NSSAUPERVISOR) VALUES (1.0,'Juan','Perez','Perez','H','R/ Villar 2','06/02/1964','D01',NULL);
--Fila 2
NSSAUPERVISOR) VALUES (2.0,'Pedro','Lopez','Blas','H','R/ Fontes 12','12/23/1950','D01',1.0);
--Fila 3
NSSAUPERVISOR) VALUES (3.0,'María','Perez','Pi','M','R/ Galicia 6','03/12/1975','D02',NULL);
--Fila 4
NSSAUPERVISOR) VALUES (4.0,'Antonio','Botin','Castro','H','Pza Galicia 1','01/13/1965','D02',3.0);
Tabla proyectos
--Fila 1
INSERT INTO Proyectos (NUMERO, NOMBRE, LOCALIDAD, NUMDEPT) VALUES ('V1','Sistema
Contable','A Coruña','D01');
--Fila 2
INSERT INTO Proyectos (NUMERO, NOMBRE, LOCALIDAD, NUMDEPT) VALUES ('P1','Producto
A','Ferrol','D02');
--Fila 3
INSERT INTO Proyectos (NUMERO, NOMBRE, LOCALIDAD, NUMDEPT) VALUES ('P2','Producto
B','Ferrol','D02');
Tabla Localidad Departamentos
--Fila 1
INSERT INTO LocalidadDept (NUMDEPT, LOC) VALUES ('D01','A Coruña');
--Fila 2
INSERT INTO LocalidadDept (NUMDEPT, LOC) VALUES ('D02','A Coruña');
--Fila 3
INSERT INTO LocalidadDept (NUMDEPT, LOC) VALUES ('D02','Ferrol');

ACTUALIZACIÓN DE REGISTROS
La modificación de los datos de los registros lo implementa la instrucción
UPDATE. Sintaxis:
Se modifican las columnas indicadas en el apartado SET con los valores

indicados. La cláusula WHERE permite especificar qué registros serán modificados.
Ejemplos:
UPDATE empleados SET provincia='Ourense' WHERE provincia='Orense';
UPDATE productos SET precio=precio*1.16;
El primer dato actualiza la provincia de los clientes de Orense para que aparezca como Ourense.
El segundo UPDATE incrementa los precios en un 16%. La expresión para el valor puede ser todo
lo compleja que se desee (en el ejemplo se utilizan funciones de fecha para conseguir que los
partidos que se juagaban hoy, pasen a jugarse el martes):
UPDATE partidos SET fecha= NEXT_DAY(SYSDATE,'Martes') WHERE fecha=SYSDATE;
En la condición se pueden utilizar cualquiera de los operadores de comparación y lógicos
que se verán en detalle mas adelante
BORRADO DE REGISTROS
Se realiza mediante la instrucción DELETE:
Es más sencilla que las anteriores, elimina los registros de la tabla que cumplan
la condición indicada.
Ejemplo: DELETE FROM empleados WHERE seccion=23;
Hay que tener en cuenta que el borrado de un registro no puede provocar fallos de
integridad y que la opción de integridad ON DELETE CASCADE hace que no sólo se
borren los registros indicados en el SELECT, sino todos los relacionados.
TRANSACCIONES
Una transacción está formada por una serie de instrucciones DML. Una transacción
comienza con la primera instrucción DML que se ejecute y finaliza con alguna de estas
circunstancias:
- Una operación COMMIT o ROLLBACK
- Una instrucción DDL (como ALTER TABLE por ejemplo)
- Una instrucción DCL (como GRANT)
- El usuario abandona la sesión
- Caída del sistema
Hay que tener en cuenta que cualquier instrucción DDL o DCL da lugar a un COMMIT
implícito, es decir todas las instrucciones DML ejecutadas hasta ese instante pasan a ser
definitivas.

 COMMIT La instrucción COMMIT hace que los cambios realizados por la transacción sean
definitivos, irrevocables. Sólo se debe utilizar si estamos de acuerdo con los cambios,
conviene asegurarse mucho antes de realizar el COMMIT ya que las instrucciones ejecutadas
pueden afectar a miles de registros. Además el cierre correcto de la sesión da lugar a un
COMMIT, aunque siempre conviene ejecutar explícitamente esta instrucción a fin de
asegurarnos de lo que hacemos.
 ROLLBACK. Esta instrucción regresa a la instrucción anterior al inicio de la transacción,
normalmente el último COMMIT, la última instrucción DDL o DCL o al inicio de sesión. Anula
definitivamente los cambios, por lo que conviene también asegurarse de esta operación. Un
abandono de sesión incorrecto o un problema de comunicación o de caída del sistema dan
lugar a un ROLLBACK implícito.
Estado de los datos durante la transacción
Si se inicia una transacción usando comandos DML hay que tener en cuenta que:
- Se puede volver a la instrucción anterior a la transacción cuando se desee
- Las instrucciones de consulta SELECT realizadas por el usuario que inició la transacción
muestran los datos ya modificados por las instrucciones DML
- El resto de usuarios ven los datos tal cual estaban antes de la transacción, de hecho los
registros afectados por la transacción aparecen bloqueados hasta que la transacción finalice.
Esos usuarios no podrán modificar los valores de dichos registros.
- Tras la transacción todos los usuarios ven los datos tal cual quedan tras el fin de transacción.
Los bloqueos son liberados y los puntos de ruptura borrados.
Otras instrucciones DDL

 Índices
Los índices son objetos que forman parte del esquema que hacen que las bases de datos
aceleren las operaciones de consulta y ordenación sobre los campos a los que el índice
hace referencia. Se almacenan aparte de la tabla a la que hace referencia, lo que
permite crearles y borrarles en cualquier momento.
Lo que realizan es una lista ordenada por la que Oracle puede acceder para facilitar la
búsqueda de los datos. cada vez que se añade un nuevo registro, los índices
involucrados se actualizan a fin de que su información esté al día. De ahí que cuantos
más índices haya, más le cuesta a Oracle añadir registros, pero más rápidas se realizan
las instrucciones de consulta.
La mayoría de los índices se crean de manera implícita, como consecuencia de las
restricciones PRIMARY KEY, UNIQUE y FOREIGN KEY. Estos son índices obligatorios,
por los que les crea el propio SGBD.
CREACIÓN DE ÍNDICES
Aparte de los índices obligatorios comentados anteriormente, se pueden crear índices de
forma explícita. Éstos se crean para aquellos campos sobre los cuales se realizarán
búsquedas e instrucciones de ordenación frecuente.
Sintaxis:
Ejemplo: CREATE INDEX nombre_completo ON empleados (apellido1, apellido2, nombreP);

El ejemplo crea un índice para los campos apellido1, apellido2 y nombre. Esto no es lo
mismo que crear un índice para cada campo, este índice es efectivo cuando se buscan u
ordenan clientes usando los tres campos (apellido1, apellido2, nombre) a la vez.
Se aconseja crear índices en campos que:
- Contengan una gran cantidad de valores
- Contengan una gran cantidad de nulos
- Sean parte habitual de cláusulas WHERE, GROUP BY u ORDER BY
- Seann parte de listados de consultas de grandes tablas sobre las que casi siempre se
muestran como mucho un 4% de su contenido.
No se aconseja en campos que:
- Pertenezcan a tablas pequeñas
- No se usen a menudo en las consultas
- Pertenecen a tablas cuyas consultas muestran menos de un 4% del total de registros
- Pertenecen a tablas que se actualizan frecuentemente
Se utilizan en expresiones
Los índices se pueden crear utilizando expresiones complejas:
CREATE INDEX nombre_complejo ON empleados (UPPER(nombre));
Esos índices tienen sentido si en las consultas se utilizan exactamente esas expresiones.
LISTA DE ÍNDICES.Para ver la lista de índices en Oracle se utiliza la vista
USER_INDEXES. Mientras que la vista USER_IND_COLUMNS Muestra la lista de
columnas que son utilizadas por índices.
BORRAR ÍNDICES. La instrucción DROP INDEX seguida del nombre del índice permite
eliminar el índice en cuestión.
 Secuencias
Una secuencia sirve para generar automáticamente números distintos. Se utilizan para
generar valores para campos que se utilizan como clave forzada (claves cuyo valor no
interesa, sólo sirven para identificar los registros de una tabla). Es decir se utilizan en
los identificadores de las tablas (campos que comienzan con la palabra id), siempre y
cuando no importe qué número se asigna a cada fila. Es una rutina interna de la base de
datos la que realiza la función de generar un número distinto cada vez. Las secuencias
se almacenan independientemente de la tabla, por lo que la misma secuencia se puede
utilizar para diversas tablas.
CREACIÓN DE SECUENCIAS
Sintaxis:

Donde:
- secuencia. Es el nombre que se le da al objeto de secuencia
- INCREMENT BY. Indica cuánto se incrementa la secuencia cada vez que se usa. Por defecto
se incrementa de uno en uno
- START WITH. Indica el valor inicial de la secuencia (por defecto 1)
- MAXVALUE. Máximo valor que puede tomar la secuencia. Si no se toma NOMAXVALUE que
permite llegar hasta el 1027
- MINVALUE. Mínimo valor que puede tomar la secuencia. Por defecto -1026
- CYCLE. Hace que la secuencia vuelva a empezar si se ha llegado al máximo valor.
Ejemplo:
CREATE SEQUENCE numeroPlanta INCREMENT 100 STARTS WITH 100 MAXVALUE 2000;
VER LISTA DE SECUENCIAS
La vista del diccionario de datos de Oracle USER_SEQUENCES muestra la lista de
secuencias actuales. La columna LAST_NUMBER muestra cual será el siguiente número
de secuencia disponible
USO DE LA SECUENCIA
Los métodos NEXTVAL y CURRVAL se utilizan para obtener el siguiente número y el
valor actual de la secuencia respectivamente. Ejemplo de uso (Oracle):
SELECT numeroPlanta.NEXTVAL FROM DUAL;
En SQL estándar: SELECT nextval(‘numeroPlanta’);
Eso muestra en pantalla el siguiente valor de la secuencia. Realmente NEXTVAL
incrementa la secuencia y devuelve el valor actual. CURRVAL devuelve el valor de la
secuencia, pero sin incrementar la misma.
Ambas funciones pueden ser utilizadas en:
- Una consulta SELECT que no lleve DISTINCT, ni grupos, ni sea parte de una vista, ni sea
subconsulta de otro SELECT, UPDATE o DELETE
- Una subconsulta SELECT en una instrucción INSERT
- La cláusula VALUES de la instrucción INSERT
- La cláusula SET de la instrucción UPDATE
No se puede utilizar (y siempre hay tentaciones para ello) como valor para la cláusula
DEFAULT de un campo de tabla.
Su uso más habitual es como apoyo al comando INSERT (en Oracle):
INSERT INTO plantas(num, uso) VALUES(numeroPlanta.NEXTVAL, 'Suites');
MODIFICAR SECUENCIAS
Se pueden modificar las secuencias, pero la modificación sólo puede afectar a
los futuros valores de la secuencia, no a los ya utilizados. Sintaxis:

BORRAR SECUENCIAS
Lo hace el comando DROP SEQUENCE seguido del nombre de la secuencia a borrar.
LISTA DE SECUENCIAS
En SQL estándar, a través de INFORMATION_SCHEMA.SEQUENCES podemos
acceder a la información sobre todas las secuencias creadas. En Oracle se hace
mediante la vista USER_SEQUENCES permite observar la lista de secuencias del
usuario.
 Sinónimos
En Oracle, un sinónimo es un nombre que se asigna a un objeto cualquiera.
Normalmente es un nombre menos descriptivo que el original a fin de facilitar la
escritura del nombre del objeto en diversas expresiones.
CREACIÓN
objeto es el objeto al que se referirá el sinónimo. La cláusula PUBLIC hace que el
sinónimo esté disponible para cualquier usuario (sólo se permite utilizar si disponemos
de privilegios administrativos).
BORRADO
LISTA DE SINÓNIMOS. La vista USER_SYNONYMS permite observar la lista de sinónimos
del usuario, la vista ALL_SYNONYMS permite mostrar la lista completa de sinónimos
de todos los esquemas a los que tenemos acceso.

DQL es la abreviatura del Data Query Language (lenguaje de consulta de datos) de

SQL. El único comando que pertenece a este lenguaje es el versátil comando SELECT
Este comando permite:
- Obtener datos de ciertas columnas de una tabla (proyección)
- Obtener registros (filas) de una tabla de acuerdo con ciertos criterios
(selección)
- Mezclar datos de tablas diferentes (asociación, join)
- Realizar cálculos sobre los datos
- Agrupar datos
CONSULTAR EL DICCIONARIO DE DATOS
Todas las bases de datos disponen de posibilidades para consultar el diccionario de
datos. Siguiendo las reglas de Codd, la forma de consultar los metadatos es la misma
que en el resto de tablas. Es decir existen tablas (en realidad vistas) que en lugar de
contener datos, contienen los metadatos.
En el caso de SQL estándar, el diccionario de datos es accesible mediante el esquema de
información (INFORMATION_SCHEMA), un esquema especial que contiene el conjunto de
vistas con el que se pueden consultar ñps metadatos de la base de datos. En concreto la
vista INFORMATION_SCHEMA.TABLES obtiene una vista de las tablas creadas.
Es decir: SELECT * FROM INFORMATION_SCHEMA.TABLES
Esa instrucción muestra una tabla con diversas columnas, entre ellas la columna
TABLE_CATALOG indica el catálogo en el que está la tabla, TABLE_SCHEMA el esquema
en el que está la tabla y TABLE_NAME el nombre de la tabla.
Muchos SGBD respetan el estándar, pero en el caso de Oracle no. Oracle utiliza diversas
vistas para mostrar las tablas de la base de datos. En concreto USER_TABLES y que
contiene una lista de las tablas del usuario actual (o del esquema actual).
Así para sacar la lista de tablas del usuario actual, se haría:
SELECT * FROM USER_TABLES;
Esta vista obtiene numerosas columnas, en concreto la columna TABLES_NAME muestra
el nombre de cada tabla del sistema; esto es accesible sólo por el usuario administrador
(DBA). En el caso de ALL_TABLES y de DBA_TABLES, la columna OWNER indica el
nombre del propietario de la tabla.
El comando DESCRIBE, permite obtener la estructura de una tabla. Aparecerán los campos
de la tabla. Esta instrucción no es parte del SQL estándar, pero casi es considerada así ya que casi
todos los SGBD la utilizan.
Otra posibilidad para poder consultar los datos referentes a las columnas de una tabla,
es utilizar el diccionario de datos.
Oracle posee una vista llamada USER_TAB_COLUMNS que permite consultar todas las
columnas de las tablas del esquema actual. Las vistas ALL_TAB_COLUMNS y
DBA_TAB_COLUMNS muestran los datos del resto de tablas (la primera sólo de las
tablas accesibles por el usuario). En el caso de SQL estándar las columnas son
accesibles mediante la vista INFORMATION_SCHEMA.COLUMNS

CONSULTAS SIMPLES
El corazón o poder del Lenguaje SQL es el poder hacer consultas de cualquier tipo a la
base de datos en forma no procedural. La sentencia SELECT es muy poderosa y
ampliamente rica en sus cláusulas y variantes permitiendo la capacidad de atender en
poco tiempo a consultas complejas sobre la base de datos. Está en el especialista
desarrollador de aplicaciones conocerlo a profundidad para explotar las bondades y
virtudes.
Se trata de una instrucción que toma como parámetros de entrada una o mas tablas, y
devuelve como resultado una nueva tabla, generada dinámicamente, que contiene la
información solicitada. El resultado puede ser desde una tabla con una única fila y una
única columna (es decir, un único valor) hasta una tabla con múltiples filas y columnas.
Gracias a esta sentencia es que se pueden realizar todas las operaciones del Algebra
Relacional. En esta sección veremos la sintaxis de como se utiliza. La sentencia SELECT,
obtiene filas de la base de datos y permite realizar la selección de una o varias filas o
columnas de una o varias tablas.
- * El asterisco significa que se seleccionan todas las columnas

- DISTINCT. Hace que no se muestren los valores duplicados.
- columna. Es el nombre de una columna de la tabla que se desea mostrar
- expresión. Una expresión válida SQL
- alias. Es un nombre que se le da a la cabecera de la columna en el resultado de esta
instrucción.
Está formada por un conjunto de cláusulas, que ayudan a precisar la información que se
solicita:
La sintaxis completa de la instrucción SELECT es compleja, pero la voy resumir como

sigue (los corchetes cuadrados indican que la cláusula no es obligatoria):
SELECT nombres de las columnas [INTO nueva Tabla destino para resultados del select_]
FROM origenTabla
[WHERE condición de Búsqueda]
[GROUP BY nombres de columnas por la cual Agrupar]
[HAVING condiciónBúsqueda para Group By ]
[ORDER BY nombre de columnas [ASC | DESC] ]
También se puede unir estas sentencias con otras por el operador UNION entre consultas
para combinar sus resultados en una sola tabla de resultados sin nombre.

Veamos cales son las funciones de cada una de las cláusulas de la sentencia SELECT.
- La cláusula SELECT: permite especificar la información a recuperar exactamente, y, de ser
necesario, el procesamiento que debe ser realizado sobre esos datos
Lista las columnas de las tablas que se desean ver en el resultado de una consulta. Además de
las columnas se pueden listas columnas a calcular por el SQL cuando actué la sentencia. Esta
cláusula no puede omitirse.
- La cláusula FROM: permite especificar la tabla o tablas de la base de datos desde donde se va
a recuperar la información que se necesita.
Lista las tablas que deben ser analizadas en la evaluación de la expresión de la cláusula WHERE
y de donde se listarán las columnas enunciadas en el SELECT. Esta cláusula no puede omitirse.
- La cláusula WHERE: permite especificar un conjunto de condiciones para la selección de los
datos que se recuperarán de las tablas para elaborar el resultado
Establece criterios de selección de ciertas filas en el resultado de la consulta gracias a las
condiciones de búsqueda. Si no se requiere condiciones de búsqueda puede omitirse y el
resultado de la consulta serán todas las filas de las tablas enunciadas en el FROM.
- La cláusula GROUP BY: especifica una consulta sumaria. En vez de producir una fila de
resultados por cada fila de datos de la base de datos, una consulta sumaria agrupa todas las
filas similares y luego produce una fila sumaria de resultados para cada grupo de los nombres
de columnas enunciado en esta cláusula. En otras palabras, esta cláusula permitirá agrupar un
conjunto de columnas con valores repetidos y utilizar las funciones de agregación sobre las
columnas con valores no repetidas. Esta cláusula puede omitirse.
- La cláusula HAVING: le dice al SQL que incluya sólo ciertos grupos producidos por la cláusula
GROUP BY en los resultados de la consulta. Al igual que la cláusula WHERE, utiliza una
condición de búsqueda para especificar los grupos deseados. La cláusula HAVING es la
encargada de condicionar la selección de los grupos en base a los valores resultantes en las
funciones agregadas utilizadas debidas que la cláusula WHERE condiciona solo para la selección
de filas individuales. Esta cláusula puede omitirse.
- La cláusula ORDER BY: permite especificar el orden en el que va a ser presentada la
información en la tabla resultante
Establecer la columna o columnas sobre las cuales las filas resultantes de la consulta deberán
ser ordenadas.
En realidad, no todas estas cláusulas deben aparecer obligatorias en una consulta
Select. Sólo las cláusulas SELECT y FROM son imprescindibles para formar una consulta
Select mínima. Muestra como resultado a todas las filas existentes en las tablas
especificadas en el FROM.
Supongamos que queremos recuperar el NSS y el nombre completo (nombre de pila +
apellidos) de todos los empleados de la empresa. Una consulta que lo permite sería la
siguiente:
SELECT NSS, NPila, Ap1, Ap2 FROM Empleado
...y el resultado de evaluar la consulta sería el siguiente:

¿Cómo se obtiene esta tabla? Una consulta Select se evalúa de la siguiente manera:
1. En primer lugar, se evalúa la cláusula FROM: es necesario determinar de qué tabla
vamos a recuperar la información: por ejemplo, EMPLEADO.
2. A continuación, se accede a la tabla indicada, y se recuperan, una a una, todas sus
filas, sobre las que será evaluada, una por una, la cláusula SELECT: cada fila de la
tabla original (EMPLEADO) va a dar lugar a una nueva fila en la tabla que contendrá el
resultado de la consulta.
3. La cláusula SELECT debe contener una lista de una o más expresiones, separadas por
comas.
- Cada una de esas expresiones será evaluada sobre cada fila de la tabla original, dando
lugar a una lista de valores atómicos (tantos como expresiones)
- La lista obtenida servirá para crear una nueva fila en la tabla resultado.
- La tabla resultado tendrá una columna por cada expresión incluida en la cláusula SELECT
- El nombre de cada columna será igual a la expresión que la genera.
4. Serán expresiones válidas (expresiones que pueden ser utilizadas en la cláusula
SELECT):
- Un valor constante, de cualquiera de los tipos de datos admitidos en SQL: por
ejemplo „Juan‟, 5, 03/02/2004. El resultado de evaluar un valor constante sobre
una fila coincide siempre con el propio valor constante.
- Un nombre de columna de aquellos incluidos en la tabla indicada en el FROM: por
ejemplo, NSS, NPila, Ap1 o Ap2. Al evaluar un nombre de columna sobre una fila
determinada, el resultado será el valor de la fila en esa columna.
- Una expresión que incluya operaciones realizadas sobre valores constantes y/o
nombres de columnas. El resultado de la expresión será el mismo que el resultado
de evaluar primero los valores constantes y los nombres de columnas, y operarlos
después.
Por ejemplo:
2
(Resultado: 2)
2+3
(Resultado: 5)
‘Fede’ + ‘rico’
(Resultado: „Federico‟)
Ap1 + Ap2
(Resultado: dada una fila de la tabla original, la concatenación de los valores de sus
columnas Ap1 y Ap2)
‘Nombre:’ + NPila
(Resultado: dada una fila de la tabla original, la concatenación de la cadena
‘Nombre:’ y el valor de la fila en la columna NPila)
Si una consulta incluye la llave primaria (pk) de una tabla en su lista de selección,
entonces cada fila de resultados será única (ya que la llave primaria (pk) tiene un valor
diferente en cada fila). Si no se incluye la llave primaria en los resultados, pueden
producirse filas duplicadas.

En el caso de nuestro ejemplo, la evaluación de la consulta se realiza como sigue:

- En primer lugar, se utiliza la cláusula FROM para determinar la tabla de origen de los
datos: Empleado, que es la tabla que contiene toda la información que necesitamos.
- A continuación, se analiza una por una cada fila de Empleado:
Para la primera fila...
...las expresiones de la cláusula SELECT se evalúan así:

NSS: 1
NPila: ‘Juan’
Ap1: ‘Pérez’
Ap2: ‘Pérez’
...y por lo tanto, la fila que se genera en la tabla resultado es:
Para la segunda fila...

NSS: 2
NPila: ‘Pedro’
Ap1: ‘López’
Ap2: ‘Blas’
...y por lo tanto, la fila que se añade a la tabla resultado es:
Para la tercera fila..

NSS: 3
NPila: ‘María’
Ap1: ‘Pérez’
Ap2: ‘Pi’
Finalmente, para la cuarta y última fila...


NSS: 4
NPila: ‘Antonio’
Ap1: ‘Botín’
Ap2: ‘Castro’
Como último paso, las filas obtenidas se unen para obtener la tabla resultante:
Como se puede apreciar, las columnas tienen por nombre la expresión (incluida
en la cláusula SELECT) que da lugar a sus valores
La consulta que hemos visto utiliza expresiones en la cláusula SELECT que están
constituidas por simples nombres de columnas. Sin embargo, podemos realizar
consultas más sofisticadas incluyendo expresiones más complejas. Por ejemplo,
podemos modificar la consulta anterior para que el nombre completo de cada empleado
aparezca en una única columna:
SELECT NSS, Ap1 + ‘ ‘ + Ap2 + ‘, ‘ + NPila FROM Empleado
En esta nueva consulta, reemplazamos las tres expresiones que se referían a las
columnas de nombre y apellidos de los empleados por una expresión única, en la que se
utiliza el operador de concatenación de cadenas (+) para unir los valores de dichas
columnas, separados por espacios y comas: se trata de una expresión en la que se
combinan nombres de atributos y valores constantes („ „ y „,‟ ).
La consulta se evaluará de la siguiente forma:
Para la primera fila...

NSS: 1
Ap1 + ‘ ‘ + Ap2 + ‘, ‘ + NPila = ‘Pérez’ + ‘ ‘ + ‘Pérez’ + ‘, ‘ + ‘Juan’ = ‘Pérez Pérez, Juan’
...y por lo tanto, la fila que se genera en la tabla resultado es:
Para la segunda fila...


NSS: 2
Ap1 + ‘ ‘ + Ap2 + ‘, ‘ + NPila = ‘López’ + ‘ ‘ + ‘Blas’ + ‘, ‘ + ‘Pedro’ = ‘López Blas, Pedro’
Para la tercera fila...

NSS: 3
Ap1 + ‘ ‘ + Ap2 + ‘, ‘ + NPila = ‘Pérez’ + ‘ ‘ + ‘Pi’ + ‘, ‘ + ‘María’ = ‘Pérez Pi, María’
Finalmente, para la cuarta y última fila...
..las expresiones de la cláusula SELECT se evalúan así:

NSS: 4
Ap1 + ‘ ‘ + Ap2 + ‘, ‘ + NPila = ‘Botín’ + ‘ ‘ + ‘Castro’ + ‘, ‘ + ‘Antonio’ = ‘Botín Castro,
Antonio’
Como último paso, las filas obtenidas se unen para obtener la tabla resultante:
Las expresiones complejas no tienen por que utilizar sólo atributos o valores de tipo
carácter. La siguiente consulta devuelve el número mensual de horas que cada
empleado le dedica a cada proyecto (que se obtienen multiplicando por 4 el número de
horas semanal por proyecto, almacenado en la tabla TrabajaEn):
SELECT NSS, Numero, Horas* 4 FROM TrabajaEn

Es fácil comprobar que el resultado de esta consulta sería la siguiente tabla:
Con este ejemplo demostramos algo que habíamos afirmado anteriormente: la

instrucción Select de SQL permite no sólo recuperar información almacenada en una BD,
sino también procesar dicha información para generar información nueva.
ORDENACIÓN
El orden inicial de los registros obtenidos por un SELECT no guarda más que una
relación respecto al orden en el que fueron introducidos. En los ejemplos anteriores
estamos asumiendo que el orden de presentación de los resultados de una consulta se
basa en el orden inicial de las filas de la tabla de partida.En realidad, nada nos garantiza
ese orden: la definición formal de SQL no nos indica nada a ese respecto. Además, la
definición del modelo relacional (que, no lo olvidemos, es la base de SQL) especifica que
una relación (una tabla) es un conjunto de tuplas: tratándose de un conjunto, el
concepto de orden no es aplicable. Si ejecutamos dos veces una misma consulta, nada
nos garantiza que los resultados aparezcan en el mismo orden las dos veces.
En realidad, se trata de un problema que tiene fácil solución: SQL incorpora, en la
instrucción SELECT, una cláusula – ORDER BY – que nos permite especificar el orden
deseado de presentación de los resultados.
El orden se establece a través de una o más expresiones de ordenación, que se incluyen
en la cláusula ORDER BY separadas por comas:
- Para cada fila de la tabla original se calculan los valores de esas expresiones.
- Las filas originales se ordenan de acuerdo a los valores resultantes de evaluar las expresiones
de ordenación: en primer lugar se tienen en cuenta los resultados de la primera expresión; se
toman después en cuenta los resultados de la segunda; y así sucesivamente.
- Los valores resultantes de cada expresión pueden ser ordenados de forma ascendente o
descendente: para ello se utilizan los modificadores ASC (la opción por defecto) y DESC.
Esas palabras significan en ascendente (de la A a la Z, de los números pequeños a los
grandes) o en descendente (de la Z a la a, de los números grandes a los pequeños)
respectivamente.
- Las filas del resultado se ordenan en función del orden establecido para las filas de la tabla
original a partir de las que son obtenidas.
Se ordena primero por el primer campo de la lista, si hay coincidencias por el segundo,
si ahí también las hay por el tercero, y así sucesivamente.
Sintaxis completa de SELECT (para una sola tabla):

Veremos a continuación dos ejemplos del uso de la cláusula ORDER BY para precisar
mejor su funcionamiento.
Ejemplo: Obtener la lista de empleados de la empresa, ordenados alfabéticamente por
sus apellidos.
SELECT NSS, Ap1+ ‘ ‘ + Ap2 + ‘,’ + Npila FROM Empleado ORDER BY Ap1, Ap2, Nombre
Esta consulta se evalúa de la siguiente forma:
Para cada fila de la tabla Empleado se evalúan las expresiones de ordenación:
Las filas se ordenan empleando la primera expresión (Ap1), de forma ascendente (la
opción por defecto):
Como se puede observar, dos filas (las correspondientes a María y Pedro) presentan en
mismo valor para Ap1. Para decidir su orden, recurrimos a la segunda expresión (Ap2)
Ya no es necesario recurrir a la última expresión (NPila) para resolver el orden final.

Conocido el orden, llega el momento de evaluar la cláusula SELECT y resolver la consulta,
respetando el orden previamente establecido.

Ejemplo: Indicar los NSS de todos los empleados de la empresa, ordenados por
departamento y por edad (los más jóvenes primero).
Ordenar por edad, de forma ascendente, implica ordenar por fecha de nacimiento (el
dato que poseemos sobre los empleados) de forma descendente. Por lo tanto, la
consulta a realizar sería esta:
SELECT NSS, NumDept FROM Empleado ORDER BY NumDept, Fnac DESC
Obsérvese el uso que se hace del modificador DESC para exigir que las filas se ordenen
por fecha de forma descendente (de mayor a menor, en lugar de de menor a mayor)
El resultado de la consulta sería el siguiente:
(Se da la casualidad en el ejemplo que el orden solicitado en origen para las tuplas es
aquel en el que las habíamos presentado inicialmente).
FILAS REPETIDAS:
El modificador DISTINCT
Supongamos que necesitamos conocer las diferentes localidades en las que nuestra
empresa dispone de alguna sede. En la base de datos contamos con información
referente a las sedes de los departamentos de la empresa (concretamente, en la tabla
LocalidadDpt); y conociendo las sedes de los departamentos, conoceremos las de la
empresa (ya que, en buena lógica, deben coincidir). Por lo tanto, la siguiente consulta
debería servir a nuestros fines:
SELECT Loc FROM LocalidadDpt
Como en los casos anteriores, la consulta se evalúa recuperando una por una las filas de
la tabla indicada y evaluando las expresiones de la cláusula SELECT sobre cada una de
ellas:
El resultado de la consulta sería este:

Como se puede apreciar, una de las localidades aparece repetida: se trata de A Coruña,
como resultado de ser obtenida como sede de dos departamentos diferentes. Esto es así
porque SQL incumple la restricción de clave del modelo relacional, que exige que en una
relación (una tabla) no puede haber filas repetidas. Así, al verse liberado de la obligación
de comprobar esta restricción, cualquier intérprete de SQL podrá procesar una consulta
mucho más rápidamente.
Sin embargo, SQL sí que permite eliminar filas repetidas en el resultado de una consulta
(aunque provocando, probablemente, un retraso adicional por parte del intérprete en la
obtención del resultado final).
Para hacerlo, la cláusula SELECT cuenta con el modificador distinct: añadiendo este
modificador a nuestra consulta...
SELECT DISTINCT Loc
FROM LocalidadDpt
...el resultado de la misma pasaría a ser este:
...de forma que obtendríamos ya los datos en la forma deseada.

Es importante resaltar que distinct permite eliminar filas repetidas, y no valores
repetidos. Por ejemplo, estas dos consultas (que nos devuelven una lista con los
nombres de los empleados y el departamento en el que trabajan):
…devolverán como resultado la misma tabla:
Si bien en la columna NumDept hay varios valores repetidos, no hay ninguna fila
repetida; por lo tanto, la presencia o no de distinct en la consulta no afecta al resultado
final.
Versión abreviada del SELECT
Es bastante usual encontrarse en la necesidad de recuperar toda la información
contenida en una tabla. Hacerlo por medio de una consulta SQL implicaría escribir uno
por uno todos los nombres de sus columnas en la cláusula SELECT:
SELECT NSS, Npila, Ap1, Ap2, Sexo, Direccion, Fnac, NumDept, NSSSupervisor
FROM Empleado
Para evitar esto, la cláusula SELECT admite un carácter comodín, que representa a todas
las columnas de una tabla: el asterisco (*). Así, la siguiente consulta sería equivalente a
la anterior: SELECT * FROM Empleado

Cálculos
Además de las columnas cuyos valores serán introducidos a la base de datos a través de
la sentencia INSERT, una consulta SQL puede incluir en su cláusula SELECT columnas
calculadas cuyo valor se calculan a partir de los valores de las otras columnas
almacenadas en las tablas. Estas columnas, son especie de una columna virtual pues no
existen físicamente en la tabla y sus valores calculados corresponden a los valores por
fila. Esta es una ventaja del SQL que evita que se tengan que diseñar columnas
calculadas físicas en la base de datos trayendo perdida en almacenamiento físico y
inconsistencia por falta de mantenimiento de la misma.
ARITMÉTICOS
Los operadores + (suma), - (resta), * (multiplicación) y / (división), se pueden utilizar
para hacer cálculos en las consultas. Cuando se utilizan como expresión en una consulta
SELECT, no modifican los datos originales sino que como resultado de la vista generada
por SELECT, aparece un nueva columna. Ejemplo:
SELECT nombre, precio,precio*1.16 FROM articulos;
Esa consulta obtiene tres columnas. La tercera tendrá como nombre la expresión
utilizada, para poner un alias basta utilizar dicho alias tras la expresión:
SELECT nombre, precio, precio*1.16 AS precio_con_iva FROM articulos;
La prioridad de esos operadores es la normal: tienen más prioridad la multiplicación y
división, después la suma y la resta. En caso de igualdad de prioridad, se realiza primero
la operación que esté más a la izquierda. Como es lógico se puede evitar cumplir esa
prioridad usando paréntesis; el interior de los paréntesis es lo que se ejecuta primero.
Cuando una expresión aritmética se calcula sobre valores NULL, el resultado es el
propio valor NULL. Se puede utilizar cualquiera de los operadores aritméticos: suma
(+), resta (-), multiplicación (*), división (/). Como es habitual, la multiplicación y la
división tienen preferencia sobre la suma y la resta en el orden de ejecución de la
instrucción; dicho orden se puede alterar mediante el uso de los paréntesis.
CONCATENACIÓN DE TEXTOS
Todas las bases de datos incluyen algún operador para encadenar textos. En
SQLSERVER es el signo + en Oracle son los signos ||.
Ejemplo (Oracle): SELECT tipo, modelo, tipo || '-' || modelo "Clave Pieza" FROM piezas;
El resultado sería:
TIPO MODELO Clave Pieza
AR 6 AR-6
AR 7 AR-7
AR 8 AR-8
AR 9 AR-9
AR 12 AR-12
AR 15 AR-15
AR 20 AR-20
AR 21 AR-21
BI 10 BI-10
BI 20 BI-20
BI 22 BI-22
BI 24 BI-24

En la mayoría de bases de datos, la función CONCAT (se describe más adelante)

realiza la misma función.
Condiciones
La cláusula WHERE
Se pueden realizar consultas que restrinjan los datos de salida de las tablas. Para ello se
utiliza la cláusula WHERE. Esta cláusula permite colocar una condición que han de
cumplir todos los registros, los que no la cumplan no aparecen en el resultado.
La cláusula WHERE permite afinar en mayor medida la recuperación de información
mediante una instrucción SELECT. Hasta ahora hemos visto cómo seleccionar cuáles de
las columnas de una tabla nos interesan; mediante WHERE podremos seleccionar
cuáles de las filas contenidas en una tabla nos interesan.
Eso nos permitirá, por ejemplo, restringir cualquiera de las consultas que hemos
realizado hasta ahora a los empleados de un determinado departamento. Así, la consulta
siguiente permitirá obtener el nombre de todos los empleados del departamento de
Ventas.
SELECT NSS, Ap1 + ‘ ‘ + Ap2 + ‘, ‘ + NPila FROM Empleado WHERE NumDept=’D01’
Para seleccionar las filas que nos interesen, la cláusula WHERE va acompañada de un
conjunto de condiciones de selección. Sólo las filas que cumplan esas condiciones serán
tenidas en cuenta para evaluar la consulta.
OPERADORES DE COMPARACIÓN
La condición de selección más sencilla que se puede definir es aquella que obliga a
comparar los valores de dos expresiones evaluadas sobre cada fila de la tabla. Se
pueden utilizar en la cláusula WHERE
La idea es que tanto Expresión1 como Expresión2 se evalúen sobre los valores de cada
fila de la tabla original. Una vez evaluados, se comparan. Si la condición especificada se
cumple, la fila se selecciona. Si la condición no se cumple, la fila es descartada.
Condiciones de Búsqueda
Operador Significado
> Mayor que
< Menor que
>= Mayor o igual que
<= Menor o igual que
= Igual
<> Distinto
!= Distinto

Se pueden utilizar tanto para comparar números como para comparar textos y fechas.
En el caso de los textos, las comparaciones se hacen en orden alfabético. Sólo que es un
orden alfabético estricto. Es decir el orden de los caracteres en la tabla de códigos.
En muchas bases de datos hay problemas con la Ñ y otros símbolos nacionales (en
especial al ordenar o comparar con el signo de mayor o menor, ya que la el orden ASCII
no respeta el orden de cada alfabeto nacional). No obstante es un problema que tiende
a arreglarse en la actualidad en todos los SGBD (en Oracle no existe problema alguno)
especialmente si son compatibles con Unicode.
En el caso del ejemplo
SELECT NSS, Ap1 + ‘ ‘ + Ap2 + ‘, ‘ + NPila FROM Empleado WHERE NumDept=’D01’
la evaluación se haría así:
En primer lugar, seleccionar las filas a utilizar para calcular el resultado, aplicando la
condición de selección del WHERE
Una vez seleccionadas las filas, se procede de la forma acostumbrada:
Otro ejemplo podría ser este: Nombres de todos los empleados de la empresa que
hayan nacido antes que Pedro.
La consulta que nos permite obtener esa información es esta:
SELECT NPila FROM Empleado WHERE Fnac<23/12/50
Y se evaluará de la siguiente forma:
Como se puede apreciar, ninguna fila de la tabla satisface la condición, por lo que el
resultado de la consulta será una tabla vacía: ¡Pedro es el empleado más viejo de la
empresa!

IS NULL
Los valores nulos también afectan a la evaluación de las condiciones de selección. La
evaluación de cualquier condición de selección en la que intervenga una expresión con
evaluación desconocida, será también desconocida.
Para una fila determinada, el resultado de una condición de búsqueda puede ser TRUE o
FALSE, o puede ser NULL debido a que una de las columnas utilizadas en la evaluación
de la condición de búsqueda contenga un valor NULL.
¿ 2 > Nulo ? -> Desconocido
¿ ‘Casa’ <> Nulo ? -> Desconocido
¿ NSS = 5 ? -> Desconocido (si NSS se evalúa a Nulo)
Siempre que no sea posible determinar si una condición se verifica para una
determinada fila, adoptaremos una postura conservadora: al ser desconocido el
resultado de la comparación, descartaremos la fila al calcular el resultado de la
condición, por si en un momento dado, y con más información, llegásemos a determinar
que la condición no se cumple.
Ejemplo: Recuperar el NSS de todos los empleados de la empresa que cuentan con un
supervisor. La consulta que nos permite obtener esta información es la siguiente:
SELECT NSS FROM Empleado WHERE NSSSupervisor > 0
…y se evalúa de la siguiente forma:
Como se puede apreciar, dos filas – correspondientes a dos empleados de la empresa –

presentan un valor nulo en la columna NSSSupervisor. En esos dos casos, la condición
¿NSSSupervisor > 0 ? no puede ser evaluada, y las dos filas se descartan. Es decir,
estamos descartando las filas correspondientes a empleados sin supervisor; que es
precisamente lo que pretendíamos hacer.
La consulta se termina de evaluar de la siguiente forma:
El siguiente ejemplo resulta más complicado de resolver:

Ejemplo: Recuperar el NSS de todos los empleados de la empresa que no tienen
supervisor. Se trata de seleccionar aquellas filas (empleados) con valor nulo en la
columna NSSSupervisor.

El problema es el siguiente: cualquier comparación con un valor nulo hará que una fila
sea descartada, precisamente lo contrario de lo que deseamos en este caso. Por
ejemplo, es fácil ver cómo la siguiente consulta...
SELECT NSS FROM Empleado WHERE NSSSupervisor = NULL
… devolvería como resultado una tabla vacía, por la propia semántica definida para la
cláusula WHERE: el operador de comparación = se evalúa a nulo si hay un nulo de por
medio, y en este caso todas las filas de la tabla original serían descartadas (en todas las
comparaciones intervendrá el valor NULL).
Para resolver este contratiempo, SQL permite una alternativa en forma de predicado
lógico2: IS NULL. Este predicado (asociado a un nombre de columna) nos permitirá
saber si el valor de dicha columna para una fila es nulo o no.
- Si el valor de la columna es nulo, IS NULL se evaluará como Verdadero
- Si el valor de la columna no es nulo, IS NULL se evaluará como Falso
Utilizando IS NULL en nuestro ejemplo, la consulta se resuelve así:
SELECT NSS FROM Empleado WHERE NSSSupervisor IS NULL
Y se evalúa de esta manera:
...siendo este el resultado final:
El predicado IS NULL presenta además una forma negada, que nos permite resolver de
forma más elegante la consulta original (la lista de empleados con jefe):
SELECT NSS FROM Empleado WHERE NSSSupervisor IS NOT NULL
Esta consulta se evalúa de esta manera:
2
Podemos entender un predicado como una función que devuelve como resultado un valor lógico
de Verdadero o Falso
...siendo ahora este el resultado final:
...ya que el predicado IS NOT NULL, asociado a un nombre de columna, presenta la

siguiente evaluación:
- Si el valor de la columna es nulo, IS NOT NULL se evaluará como Falso
- Si el valor de la columna no es nulo, IS NOT NULL se evaluará como
Verdadero
VALORES LÓGICOS
La cláusula WHERE permite especificar condiciones más complejas de consulta, por
medio de las conectivas lógicas: AND , OR y NOT. Las conectivas lógicas permiten
combinar dos o más condiciones (simples o compuestas), de la siguiente forma:
Condiciones de Búsqueda Compuestas

Operador Significado
Devuelve verdadero si las expresiones a su izquierda y derecha

AND
son ambas verdaderas
Devuelve verdadero si cualquiera de las dos expresiones a
OR
izquierda y derecha del OR, son verdaderas
Invierte la lógica de la expresión que está a su derecha. Si era
NOT
verdadera, mediante NOT pasa a ser falso.
La mejor forma de entender la forma de especificar una condición de selección
compuesta es con un ejemplo. Supongamos que pretendemos realizar la siguiente
consulta:
Ejemplo: Recuperar los NSS de todos aquellos empleados del departamento de Ventas
que tienen jefe.

En esta consulta tenemos que seleccionar a los empleados a mostrar de acuerdo

con dos condiciones:
- Por un lado, los empleados deben pertenecer al departamento de Ventas (D01)
- Por otro lado, los empleados deben tener un supervisor (un jefe)
Se trata claramente de una condición compuesta. La consulta que proporciona esta
información es esta:
SELECT NSS
FROM Empleado
WHERE NumDept=’D01’ AND NSSSupervisor IS NOT NULL
Como se puede apreciar, se piden dos condiciones que deben cumplirse a la vez (de ahí
que usemos la conectiva AND). La consulta se evalúa como sigue:
Como se ve, solo hay un empleado que cumpla las dos condiciones. El resultado de la
consulta sería este:
Supongamos ahora que la información solicitada es la siguiente:

Ejemplo: Recuperar los NSS de todos aquellos empleados de la empresa que o bien
pertenezcan al departamento de Ventas o bien tengan jefe.
En este caso, las condiciones indicadas varían ligeramente: ya no se trata de dos

condiciones que deban cumplirse juntas; ahora nos interesan los empleados que
cumplan una cualquiera de ellas. Por lo tanto, la conectiva a utilizar es, en este caso,
OR:
SELECT NSS FROM Empleado
WHERE NumDept=’D01’ OR NSSSupervisor IS NOT NULL
Esta nueva consulta se evalúa como sigue:

Como se ve, solo hay un empleado que no cumple ninguna de las dos condiciones, y
que por lo tanto debe ser descartado. El resultado de la consulta sería este:
Otro ejemplo podría ser este:

Seleccionar a aquellos empleados que no trabajen en el departamento de Ventas.
Se trata de una consulta ideal para el uso de NOT, ya que debemos establecer como
condición que algo no se cumpla.
SELECT distinct NSS FROM Empleado
WHERE NOT(NumDept=’D01’)
Como se puede ver, seleccionamos exclusivamente a aquellos empleados que no

pertenecen a Ventas.
Analizaremos un último ejemplo, algo más complejo de lo que podría parecer en un

principio: Seleccionar a los empleados cuyo jefe no es Juan.
Aparentemente, esta consulta se resuelve fácilmente utilizando de nuevo el predicado
NOT:
SELECT NSS FROM Empleado WHERE NOT(NSSSupervisor=1)
Es decir, seleccionamos a aquellos empleados cuyo jefe no tenga 1 por valor de NSS
(que es el de Juan).

Como se puede apreciar, estamos descartando las filas correspondientes a dos

empleados (Juan y María) ¡que no tienen a Juan como jefe! (De hecho, ninguno de
los dos tiene jefe); y que por lo tanto deberían aparecer en el resultado de la consulta.
La culpa de que no aparezcan es de los valores nulos. Efectivamente, ni Juan ni María
tienen jefe, por lo que NSSSupervisor toma para ambos el valor Nulo. Al comparar
NSSSupervisor con 1 (el NSS de Juan), el resultado es desconocido, por lo que ambas
filas resultan descartadas.
Se impone por lo tanto una modificación de la consulta, para tratar convenientemente
todos aquellos casos en los que NSSSupervisor sea Nulo. La forma de hacerlo es esta:
SELECT NSS FROM Empleado WHERE NOT(NSSSupervisor=1) OR NSSSupervisor IS NULL
Es decir, serán incluidos en el resultado todos aquellos empleados que no tengan jefe
(NSSSupervisor IS NULL) o bien, si tienen jefe, su NSS no sea 1 (el de Juan)
Ahora sí hemos conseguido descartar solamente a Pedro, que es el único empleado que
tiene a Juan por jefe.
Como hemos podido comprobar en este ejemplo, la presencia de valores nulos complica
siempre la realización de consultas. Se trata de uno de los motivos por los que – como
ya ha sido señalado en alguna ocasión – el diseño de las tablas de una BD debe ser
analizado detenidamente para evitar en lo posible la necesidad del uso de valores nulos.
BETWEEN El operador BETWEEN nos permite obtener datos que se encuentren en un
rango. Uso: SELECT tipo,modelo,precio FROM piezas WHERE precio BETWEEN 3 AND 8;
Saca piezas cuyos precios estén entre 3 y 8 (ambos incluidos).
IN Permite obtener registros cuyos valores estén en una lista de valores:
SELECT tipo,modelo,precio FROM piezas WHERE precio IN (3,5, 8);
Obtiene piezas cuyos precios sean 3, 5 u 8 (no valen ni el precio 4 ni el 6, por ejemplo).
LIKE Se usa sobre todo con textos, permite obtener registros cuyo valor en un campo
cumpla una condición textual. LIKE utiliza una cadena que puede contener estos
símbolos:
% Una serie cualquiera de caracteres
_ Un carácter cualquiera

Ejemplos:
/* Selecciona nombres que empiecen por S */
SELECT nombre FROM personas WHERE nombre LIKE 'S%';
/*Selecciona las personas cuyo apellido sea Sanchez, Senchez, Stnchez,...*/
SELECT apellido1 FROM Personas WHERE apellido1
LIKE 'S_nchez';
PRECEDENCIA DE OPERADORES
A veces las expresiones que se producen en los SELECT son muy extensas y es difícil
saber que parte de la expresión se evalúa primero, por ello se indica la siguiente tabla
de precedencia (tomada de Oracle):
Orden de
Operador
precedencia
1 *(Multiplicar) / (dividir)
2 + (Suma) - (Resta)
3 || (Concatenación)
4 Comparaciones (>, <, !=, ...)
5 IS [NOT] NULL, [NOT ]LIKE, IN
6 NOT
7 AND
8 OR
FUNCIONES
Todos los SGBD implementan funciones para facilitar la creación de consultas complejas.
Esas funciones dependen del SGBD que utilicemos, las que aquí se comentan son
algunas de las que se utilizan con Oracle.
Todas las funciones devuelven un resultado que procede de un determinado cálculo. La
mayoría de funciones precisan que se les envíe datos de entrada (parámetros o
argumentos) que son necesarios para realizar el cálculo de la función.
Este resultado, lógicamente depende de los parámetros enviados. Dichos parámetros se
pasan entre paréntesis.
De tal manera que la forma de invocar a una función es:
Si una función no precisa parámetros (como SYSDATE) no hace falta colocar los
paréntesis.
En realidad hay dos tipos de funciones:
- Funciones que operan con datos de la misma fila
- Funciones que operan con datos de varias filas diferentes (funciones de
agrupación).
En LA Página 122 Alvaro E. García Manual Práctico de SQL, ORIENTADO A SQL 7.0
(noviembre de 2003) se describen algunas de las funciones más interesantes.

Consultas a Múltiples Tablas

Hasta ahora, todos los ejemplos que hemos visto se referían a consultas que permitían
recuperar la información contenida en una única tabla. Sin embargo, en muchas
ocasiones va a ser necesario combinar los datos almacenados en varias tablas para
poder obtener la información que se necesite.
Las bases de datos relacionales se basan en que los datos se distribuyen en tablas que
se pueden relacionar mediante un campo. Ese campo es el que permite integrar los
datos de las tablas.
Supongamos por ejemplo esta petición de información:
Obtener los nombres de todos los empleados de la empresa, junto con el nombre de los
departamentos en los que trabajan.
La principal dificultad de escribir una consulta que obtenga esta información radica
precisamente en que la información está distribuida en dos tablas:
- El nombre de los empleados se encuentra en la tabla Empleado
- El nombre de los departamentos se encuentra en la tabla Departamento
Sin embargo, ambas tablas incluyen una columna común: NumDept. Esta columna, en
la tabla Empleado, nos permite representar/averiguar el número del departamento
correspondiente a cada empleado. A partir de ese número, podemos localizar la fila
correspondiente en la tabla Departamento y averiguar los datos del mismo.
Para resolver el problema, SQL nos permite especificar dos o más tablas (separadas por
comas) en la cláusula FROM; es decir, podemos especificar que queremos extraer la
información desde dos o más tablas de la BD.
Generalmente el poder de la sentencia SELECT se basa en su capacidad de poder en una
sola sentencia consultar múltiples tablas simultáneamente. Esta operación también se le
llama JOIN y es lo que en particular llamo un "pegue de tablas en forma horizontal" y
ocurre gracias a que existen columnas de conexión ósea atributos de asociación
comunes en las tablas que se unen en esta forma, produce un producto cruzado
Para que se puedan realizar consultas a múltiples tablas el requisito principal es que las
tablas a reunirse en una consulta tengan columnas con valores o dominios comunes, es
decir columna de conexión.

Si reunimos a las tablas de la figura, de tal forma que la Tabla1 se reúna con la Tabla2 y
la Tabla2 se reuniera con la Tabla3, el requisito indispensable sería: la Tabla1 debe
tener una columna común en la Tabla2 y Tabla2 debe tener una columna de conexión en
la Tabla3.
Por lo general estas columnas comunes son: en una tabla la columna es la llave primaria
y en la otra tabla la columna asociada es la llave foránea que referencia a la primaria.
Para este tipo de consultas a múltiples tablas la cláusula FROM es la responsable de
indicar cual será la(s) tabla(s) fuentes.
Existen dos formas de sintaxis permitidas para la escritura de la sentencia SELECT para
la reunión de tablas, basada en la figura 4.4.a, estas formas son las siguientes:
FORMA 1:
SELECT a1, a2, a5, b1, b2, b3, c1, c2, c3 FROM Tabla1, Tabla2, Tabla3
WHERE Tabla1.a1 = Tabla2.b2 AND Tabla2. b1 = Tabla3.c1
FORMA 2:
SELECT a1, a2, a5, b1, b2, b3, c1, c2, c3 FROM Tabla1
INNER JOIN Tabla2 ON Tabla1.a1 = Tabla2.b2
INNER JOIN Tabla3 Tabla2. b1 = Tabla3.c1
Note que las columnas comunes en ambas tablas han de calificarse con el nombre de la
tabla que pertenecen para evitar errores de ambigüedad.
La Forma 2, tiene la ventaja de liberar a la cláusula WHERE y dejar esta para filtros
específicos sobre las filas resultantes de la reunión de tablas.
Sin embargo, la evaluación de la consulta va a diferir ligeramente con respecto al
mecanismo que habíamos visto hasta ahora. Dicho mecanismo de evaluación constaba
de los siguientes pasos:
1. Determinar la tabla de origen, indicada en la cláusula FROM
2. Seleccionar aquellas filas que cumplen la condición o condiciones especificadas en la
cláusula WHERE
3. Ordenar las filas de la tabla original de acuerdo con lo especificado en la cláusula ORDER
BY
4. A partir de cada fila de la tabla original, generar una fila en la tabla resultante, a partir de
la evaluación de las expresiones indicadas en la cláusula SELECT
El mecanismo a seguir en el caso de consultas definidas sobre varias tablas va a ser
ahora:
1. Determinar las tablas de origen, indicadas en la cláusula FROM
2. Combinar las tablas originales, de forma que se genere una tabla única sobre la que
trabajar.
3. Seleccionar aquellas filas de la tabla original que cumplen la condición o condiciones
especificadas en la cláusula WHERE
4. Ordenar las filas de la tabla original de acuerdo con lo especificado en la cláusula ORDER
BY
5. A partir de cada fila de la tabla original, generar una fila en la tabla resultante, a partir de
la evaluación de las expresiones indicadas en la cláusula SELECT
Como se puede apreciar, los cambios (2 y 3) son mínimos: La esencia del cambio radica
en que vamos a obtener, de las tablas originales, una nueva tabla, única, sobre la que
trabajar.

Una vez obtenida esa tabla, podremos continuar procediendo como habíamos visto hasta
ahora: evaluando las cláusulas WHERE, ORDER BY y SELECT sobre una única tabla.
Evidentemente, la clave del correcto funcionamiento de la consulta está en la forma en
la que se realizará la combinación de las (dos o mas) tablas originales. La idea es
combinar las filas de una tabla con las filas que tenga asociadas en el resto de tablas. En
el caso de nuestro ejemplo, deberíamos intentar combinar cada fila correspondiente a un
empleado con la fila correspondiente a su departamento. De esta forma, en la tabla
combinada seguiríamos contando con una fila por cada empleado, que incluiría además
toda la información relativa a su departamento.
Como se puede apreciar, sería sencillo definir una consulta sobre la tabla combinada
para recuperar la información que se solicita en el ejemplo.
Esa tabla combinada se obtiene, en SQL, en dos pasos:

1. En primer lugar, se realiza el producto cartesiano de los conjuntos de filas de todas
las tablas. Es decir, se establecen todas las combinaciones posibles de cada fila de
una tabla con las filas de todas las demás tablas, ¡tengan o no sentido!
En el caso de la consulta de nuestro ejemplo, sabemos ya que la cláusula FROM
contendrá dos tablas: Empleado y Departamento.
SELECT FROM Empleado, Departamento WHERE
Esas dos tablas serán combinadas, (producto cartesiano) dando lugar a una tabla única:
cada fila de la tabla Empleado será combinada con todas y cada una de las filas de la
tabla Departamento, dando lugar a una nueva fila en la tabla combinada. Es decir, si en
la tabla Empleado tenemos 4 filas, y en la tabla Departamento tenemos 2 filas, la
tabla combinada tendrá un total de 4 x 2 = 8 filas.

Tabla Combinada: Paso 1
Como se ve en la figura, en la tabla resultante del primer paso han sido incluidas las
siguientes combinaciones:
- La fila del empleado 1 (Juan) ha sido combinada con las filas de los departamentos D01 y D02
- La fila del empleado 2 (Pedro) ha sido combinada con las filas de los departamentos D01 y D02
- La fila del empleado 3 (María) ha sido combinada con las filas de los departamentos D01 y D02
- La fila del empleado 4 (Antonio) ha sido combinada con las filas de los departamentos D01 y
D02
...resultando un total de 8 filas, tal y como habíamos calculado
El producto cartesiano a veces es útil para realizar consultas complejas, pero en el
caso normal no lo es. Necesitamos discriminar ese producto para que sólo aparezcan los
registros de empleados relacionadas con los de departamento. A eso se le llama asociar
(join) tablas
2. No todas las combinaciones realizadas tienen interés para nosotros. Atendiendo a la

consulta que queremos realizar, sólo son relevantes aquellas en las que los datos de
un empleado han sido combinados con los datos del departamento en el que trabaja.
El segundo paso consiste en seleccionar aquellas combinaciones de interés, por
medio del establecimiento de una o más condiciones de reunión: las condiciones que
hacen válida una combinación de filas de diferentes tablas.
¿Cómo se especifican las condiciones de reunión? Aprovechando un mecanismo ya
conocido: la cláusula WHERE. Ampliaremos las condiciones de esta cláusula incluyendo
aquellas que convierten en válidas a las filas de la tabla combinada.
En el caso de nuestro ejemplo, para nosotros serán válidas aquellas combinaciones de
filas de empleado y departamento para las que el valor de NumDepto coincida. Esa
será pues, la condición de reunión a establecer en la cláusula WHERE.
SELECT *
FROM Empleado, Departamento
WHERE NumDept = NumDept

Un problema de combinar varias tablas es que la tabla combinada puede acabar

incluyendo varias columnas con el mismo nombre. Nuestro ejemplo no podía ser menos
y existen varias columnas en esa situación en la tabla combinada: NSS, procedente de
la tabla Empleado (representa el NSS de cada empleado) y NSS, procedente de la tabla
Departamento (que representa el NSS del director del departamento); NumDept,
procedente de la tabla Empleado (que representa el número de departamento de cada
empleado de la empresa), y NumDept, procedente de la tabla Departamento (que
representa en número de cada departamento de la empresa).
¿Cómo distinguirlas cuando nos refiramos a ellas? (por ejemplo, en la condición de
reunión NumDept = NumDept)
Para solucionar esta aparente ambigüedad, lo que haremos será utilizar prefijos para
designar a las columnas: cada nombre de columna, cuando la referenciemos, irá
precedida del nombre de la tabla de la que provenga, separando ambos nombres por un
punto (.)
Así, la consulta de reunión de nuestro ejemplo pasa a ser...
SELECT
FROM Empleado, Departamento
WHERE Empleado.NumDept = Departamento.NumDept
…y de este modo resolvemos cualquier posible ambigüedad en cuanto a las columnas a
las que nos referimos en la condición. Podemos así seleccionar las filas que son
coherentes:
Tabla Combinada: Paso 2
Resultando la tabla combinada final:

Tabla Combinada después del paso 2

Una vez obtenida la tabla combinada definitiva, es posible ya comprobar el resto de

condiciones especificadas en la cláusula WHERE, evaluar las expresiones de la cláusula
SELECT y calcular el resultado final
SELECT Npila, NomDept FROM Empleado, Departamento
WHERE Empleado.NumDept = Departamento.NumDept
Es necesario observar que, de pretender incluir en el resultado el número del

departamento, deberíamos especificar de cuál de las dos columnas con el mismo
nombre de la tabla combinada pretenderíamos extraerlo. Las posibilidades serían dos: la
columna procedente de Empleado, o la columna procedente de Departamento.
Cualquiera de las dos opciones sería válida
Consultas que involucran varias veces a la misma tabla.

¿Qué sucede cuando tenemos una clave foránea que referencia a una clave primaria de
la misma tabla? ¡Que las cosas se complican!
Volvamos a nuestro ejemplo: la tabla Empleado contiene una clave foránea de ese tipo:
NSSSupervisor. Esta columna permite almacenar, para cada empleado, el NSS de su
jefe, que a su vez es un empleado y debe estar registrado en la tabla. Sin embargo, no
se incluye una columna para poder registrar el nombre del jefe da cada empleado entre
el resto de sus datos. Supongamos ahora que nos hacen llegar la siguiente petición:
Para todos aquellos empleados de la empresa que tengan jefe, se necesita la lista de sus
nombres y los nombres de sus jefes inmediatos.
Es fácil pensar cómo obtener manualmente la información:
- Se recuperan los datos de todos los empleados con jefe de la empresa: todas las filas de la
tabla Empleado con NSSSupervisor no nulo.
- De cada fila, nos quedamos con el nombre del empleado (NPila) y el NSS de su supervisor
(NSSSupervisor).
- Utilizamos el NSS del supervisor, y localizamos la fila que le corresponde en la tabla (de
nuevo) Empleado.
- Recuperamos de la fila el nombre del supervisor (NPila)

Como se puede ver, estamos dando dos usos a la tabla Empleado; o, dicho de otra
manera, estamos contemplando la tabla desde dos puntos de vista:
1. Tabla que mantiene información sobre los empleados de la empresa.
2. Tabla que mantiene información sobre los jefes de la empresa.
O lo que es lo mismo: estamos combinando una tabla ¡consigo misma!
Este hecho sugiere una posible vía para la elaboración de una consulta SQL que permita
obtener la información deseada: incluir dos veces la misma tabla (Empleado) en la
cláusula FROM; y combinar las “dos” tablas de forma que cada fila de un empleado se
una a la fila correspondiente a su jefe. De ese modo, la tabla resultante tendrá una fila
por cada empleado de la empresa, e incluirá en cada una de ellas el nombre del
empleado, y el nombre de su jefe: precisamente, la información que necesitamos.
La consulta a realizar sería esta:
SELECT Emp.Npila, Jefe.NPila FROM Empleado Emp, Empleado Jefe
WHERE Emp.NSSSupervisor = Jefe.NSS
Para poder entender la consulta, debemos aclarar una serie de cuestiones:
- Incluir dos veces a Empleado la misma tabla en la cláusula FROM nos da la ilusión de contar
con dos copias exactamente iguales de la tabla: una con información sobre empleados y otra
con información sobre jefes.
- Para poder diferenciar cada una de las “copias”, utilizaremos sendos alias de la tabla:
nombres (apodos) que le daremos a la tabla original cada vez que la incluyamos en la
cláusula FROM, y que utilizaremos en todo el resto de la consulta para referirnos a cada una
de las “copias” resultantes.
En el ejemplo, usamos el alias Emp para referirnos a la tabla Empleado en su papel de
contenedora de información sobre los empleados; y el alias Jefe para referirnos a
Empleado en su papel de contenedora de información sobre los jefes - supervisores - de
empleados.
- Cada vez que debamos referirnos a una columna de alguna de las “copias”, usaremos el alias
como prefijo para indicar de cuál de ellas. Si queremos acceder a un dato sobre un
empleado, usamos la “copia” Emp; y si queremos referirnos a un dato sobre un jefe, usamos
la “copia” Jefe.
- Para combinar los datos de cada empleado con los datos de su jefe, establecemos la condición
de reunión siguiente: una fila de la “copia” Emp y otra de la “copia” Jefe se unirán si la
segunda representa al jefe del empleado representado por la primera: es decir, si el NSS de
la segunda (Jefe.NSS) es igual al NSS del jefe indicado por la primera (Emp.NSSSupervisor).
Podemos verlo mejor acudiendo a los datos, y viendo cómo se combinan. Partimos de
dos “copias” idénticas de la tabla Empleado: Emp y Jefe

Al evaluar la consulta, combinamos las dos “copias”, resultando la tabla siguiente:
Y al evaluar la condición de reunión, el resultado será este otro:
Nos quedamos, pues, con sólo dos filas, sobre las que evaluamos las expresiones del
SELECT:
Y conseguimos así la información que necesitábamos, con una consulta de lo más

sencilla.

Vistas
Una vista, en SQL, es una consulta a la que se le asigna un nombre. De ese modo
podemos utilizar una consulta como si fuese una tabla, e incluirla incluso en otras
consultas. La utilidad principal de las vistas es proporcionar una manera de dar
diferentes visiones de la BD a los diferentes usuarios de la misma3.
Lo veremos con un ejemplo: comprobaremos como mediante una vista podemos ampliar
la tabla Empleado permitiendo representar en ella un atributo derivado (la edad del
empleado), calculada con una función especial de SQL (datediff) que permite calcular la
diferencia en años entre dos fechas dadas.
La consulta que nos permite añadir esa columna a la tabla Empleado es esta:
SELECT *, DateDiff("yyyy", FNac,Now()) AS Edad
FROM Empleado
...con el siguiente resultado:
Para convertir esta consulta en una vista, utilizamos la instrucción de SQL CREATE
VIEW, que presenta la siguiente sintaxis:
CREATE VIEW <Nombre vista> AS <Consulta Select>
En el caso de nuestro ejemplo:
CREATE VIEW EmpleadoEdad AS
SELECT *, DateDiff("yyyy", FNac,Now()) AS Edad
FROM Empleado
Una vez definida la vista, ya podrá ser utilizada en cualquier consulta:
SELECT * FROM EmpleadoEdad
NOTA: Access no soporta la definición de vistas. En su lugar, todas las consultas
creadas en Access se convierten implícitamente en una vista.
3
Recordar el nivel externo de la arquitectura de la información, ya visto anteriormente
Implementación de la BD
Para cada caso, elija un motor de BD y explique el paso, a paso de su creación y
manipulación.
CASO PRACTICO 1: Gestión fondos de un museo
CREATE TABLE PLANTAS (

Numero VARCHAR2(4) NOT NULL,
D1_N_salas INTEGER NOT NULL,
CONSTRAINT pk_plantas PRIMARY KEY (numero)
);
CREATE TABLE SALAS (

num_sala VARCHAR2(7) NOT NULL,
num_planta VARCHAR2(4) NOT NULL,
max_cuadros INTEGER NOT NULL,
D2_N_cuadros INTEGER NOT NULL,
CONSTRAINT pk_salas PRIMARY KEY (num_sala,num_planta),
CONSTRAINT fk_plantas_salas FOREIGN KEY (num_planta)
REFERENCES PLANTAS
ON DELETE CASCADE
);
CREATE TABLE PINTORES (

cod_pintor INTEGER NOT NULL,
nombre VARCHAR2(50),
nom_artistico VARCHAR2(20) NOT NULL,
nacionalidad VARCHAR2(20) NOT NULL,
fecha_nac DATE NOT NULL,
fecha_fall DATE,
CONSTRAINT pk_pintores PRIMARY KEY (cod_pintor),
CONSTRAINT uk_pintores UNIQUE (nom_artistico),
CHECK (fecha_nac<fecha_fall)
);
CREATE TABLE ESTILOS (

nombre VARCHAR2(20) NOT NULL,
fecha_ini DATE NOT NULL,
fecha_fin DATE,
CONSTRAINT pk_estilos PRIMARY KEY (nombre),
CHECK ( fecha_ini<fecha_fin )
);
CREATE TABLE COLECCIONES (

codigo INTEGER NOT NULL,
direccion VARCHAR2(20) NOT NULL,
CONSTRAINT pk_coleccion PRIMARY KEY (codigo)
);
CREATE TABLE CUADROS (

titulo VARCHAR2(50) NOT NULL,

tecnica VARCHAR2(20) NOT NULL,

fecha DATE NOT NULL,
pintor INTEGER NOT NULL,
estilo VARCHAR2(20) NOT NULL,
tipo_cuadro VARCHAR2(20) NOT NULL,
CONSTRAINT pk_cuadros PRIMARY KEY (pintor,titulo),
CONSTRAINT fk_pintores_cuadros FOREIGN KEY (pintor)
REFERENCES PINTORES
ON DELETE CASCADE,
CONSTRAINT fk_estilos_cuadros FOREIGN KEY (estilo)
REFERENCES ESTILOS,
CHECK (tecnica IN ('oleo', 'temple', 'acrílico', 'esmalte')),
CHECK (tipo_cuadro IN ('propio', 'ajeno'))
);
CREATE TABLE AJENOS (

CONSTRAINT pk_ajenos PRIMARY KEY (pintor,titulo),
CONSTRAINT fk_cuadros_ajenos FOREIGN KEY (pintor,titulo)
REFERENCES CUADROS
ON DELETE CASCADE
);
CREATE TABLE PROPIOS (

per_restauracion VARCHAR2(5) NOT NULL,
coleccion INTEGER,
CONSTRAINT pk_propios PRIMARY KEY (pintor,titulo),
CONSTRAINT fk_cuadros_propios FOREIGN KEY (pintor,titulo)
REFERENCES CUADROS
ON DELETE CASCADE,
CONSTRAINT fk_colecciones_propios FOREIGN KEY (coleccion)
REFERENCES COLECCIONES
);
CREATE TABLE EXPUESTOS (

num_sala VARCHAR2(7) NOT NULL,
num_planta VARCHAR2(4) NOT NULL,
fecha_fin DATE,
CONSTRAINT pk_expuestos PRIMARY KEY (pintor,titulo,fecha_ini),
CONSTRAINT uk_expuestos UNIQUE (pintor, titulo, fecha_fin),
CONSTRAINT fk_salas_expuestos FOREIGN KEY (num_sala,num_planta)
REFERENCES SALAS,
CONSTRAINT fk_propios_expuestos FOREIGN KEY (pintor, titulo)
REFERENCES PROPIOS,
);
CREATE TABLE PERSONAL (


tipo_profesion VARCHAR2(20) NOT NULL,
CONSTRAINT pk_personal PRIMARY KEY (codigo),
CHECK (tipo_profesion IN ('conservador', 'restaurador'))
);
CREATE TABLE CONSERVADORES (

estilo VARCHAR2(20) NOT NULL,
CONSTRAINT pk_conservadores PRIMARY KEY (codigo),
CONSTRAINT fk_estilos_conservadores FOREIGN KEY (estilo)
REFERENCES ESTILOS,
CONSTRAINT fk_personal_conservadores FOREIGN KEY (codigo)
REFERENCES PERSONAL
ON DELETE CASCADE
);
CREATE TABLE RESTAURADORES (

CONSTRAINT pk_restauradores PRIMARY KEY (codigo),
CONSTRAINT fk_personal_restauradores FOREIGN KEY (codigo)
REFERENCES PERSONAL
ON DELETE CASCADE
);
CREATE TABLE REST (

fecha_fin DATE NOT NULL,
CONSTRAINT pk_rest PRIMARY KEY (codigo,pintor,titulo,
fecha_ini),
CONSTRAINT fk_restauradores_rest FOREIGN KEY (codigo)
REFERENCES RESTAURADORES,
CONSTRAINT FK_propios_rest FOREIGN KEY (pintor,titulo)
REFERENCES PROPIOS,
);
CREATE TABLE PUEDE_REST (

restaurador INTEGER NOT NULL,
CONSTRAINT pk_puede_rest PRIMARY KEY (restaurador, pintor),
CONSTRAINT fk_puede_rest_restauradores FOREIGN KEY (restaurador)
REFERENCES RESTAURADORES,
CONSTRAINT fk_puede_rest_pintores FOREIGN KEY (pintor)
REFERENCES PINTORES
);
CREATE TABLE REST_PROXIMAS (

restaurador INTEGER NOT NULL,


D4_fecha_prox DATE NOT NULL,
CONSTRAINT pk_rest_proximas PRIMARY KEY (restaurador),
CONSTRAINT uk_rest_proximas UNIQUE (pintor,titulo),
CONSTRAINT fk_propios_rest_proximas FOREIGN KEY (pintor,titulo)
REFERENCES PROPIOS
);
CREATE TABLE EXPO_TEMP (

Titulo VARCHAR2(50) NOT NULL,
D3_N_cuadros INTEGER NOT NULL,
fecha_fin DATE NOT NULL,
CONSTRAINT pk_expo_temp PRIMARY KEY (titulo),
);
CREATE TABLE PREST_INTERNOS (

exposicion VARCHAR2(40) NOT NULL,
CONSTRAINT pk_prest_internos PRIMARY KEY (pintor, titulo, exposicion),
CONSTRAINT fk_propios_prest_internos FOREIGN KEY (pintor,titulo)
REFERENCES PROPIOS,
CONSTRAINT fk_expo_temp_prest_internos FOREIGN KEY (exposicion)
REFERENCES EXPO_TEMP
);
CREATE TABLE TELEFONOS (

telefono VARCHAR2(20) NOT NULL,
CONSTRAINT pk_telefonos PRIMARY KEY (telefono),
CONSTRAINT fk_colecciones_telefonos FOREIGN KEY (codigo)
REFERENCES COLECCIONES
);
CREATE TABLE PREST_EXT_EXPO (

coleccion INTEGER NOT NULL,
exposicion VARCHAR2(40) NOT NULL,
CONSTRAINT pk_prest_ext_expo
PRIMARY KEY (pintor,titulo,exposicion),
CONSTRAINT fk_colecciones_prest_ext_expo FOREIGN KEY (coleccion)
REFERENCES COLECCIONES,
CONSTRAINT fk_expo_temp_prest_ext_expo FOREIGN KEY (exposicion)
REFERENCES EXPO_TEMP,
CONSTRAINT fk_ajenos_prest_ext_expo FOREIGN KEY (pintor,titulo)
REFERENCES AJENOS
);
Para implementar la base de datos con todas sus restricciones en el SGBD ORACLE, hay
que añadir al script de creación expuesto TRIGGER

A continuación, como ejemplo4, se va a mostrar el código de dos TRIGGER

representativos
A continuación se muestra el TRIGGER “Trigger_Calculo_cuadros_sala”, que calcula el
número de cuadros por sala, valor de D2_N_cuadros de la tabla SALAS.
Será un TRIGGER que se ejecutará después de insertar, borrar o modificar en la tabla
EXPUESTOS.
CREATE OR REPLACE TRIGGER Trigger_Calculo_cuadros_sala

AFTER INSERT OR DELETE OR UPDATE ON Expuestos FOR EACH ROW
DECLARE
fecha DATE;
actual BOOLEAN;
BEGIN
SELECT SYSDATE INTO fecha FROM dual;
IF INSERTING
THEN BEGIN
IF (:new.fecha_ini<fecha) AND
(fecha < :new.fecha_finor :new.fecha_fin = null)
THEN
UPDATE salas SET D2_N_cuadros=D2_N_cuadros+1
WHERE (num_sala=:new.num_sala) AND
(num_planta=:new.num_planta);
END IF;
END;
ELSIF DELETING
THEN BEGIN
IF (:old.fecha_ini<fecha) AND
(fecha < :old.fecha_finor :old.fecha_fin = null)
THEN
UPDATE salas SET D2_N_cuadros=D2_N_cuadros-1
WHERE (num_sala=:old.num_sala) AND
(num_planta=:old.num_planta);
END IF;
END;
ELSE BEGIN
IF (:old.fecha_ini<fecha) AND
(fecha < :old.fecha_finor :old.fecha_fin = null)
THEN
UPDATE salas SET D2_N_cuadros=D2_N_cuadros-1
WHERE (num_sala=:old.num_sala) AND
(num_planta=:old.num_planta);
END IF;
IF (:new.fecha_ini< fecha) AND
(fecha < :new.fecha_finor :new.fecha_fin = null)
THEN
UPDATE salas SET D2_N_cuadros=D2_N_cuadros+1
WHERE (num_sala=:new.num_sala) AND
(num_planta=:new.num_planta);
END IF;
END;
4
Libro, Desarrollo_de_Bases_de_Datos_2a_Ed
END IF;
END;
/
Por segundo disparador se muestra como ejemplo de TRIGGER, uno que comprueba que un restaurador
sólo trabaja en restauraciones de cuadros de pintores que tenga asignado. Se ejecutará antes de insertar en la
tabla REST. Consulta la tabla PUEDE_REST para hacer la comprobación, en el caso de que el pintor del cuadro
a restaurar no sea de los asignados al restautador, el TRIGGER no permitirá realizar la operación.
CREATE OR REPLACE TRIGGER Trigger_puede_restaurar

BEFORE INSERT ON rest FOR EACH ROW
DECLARE
pintor_asignado INTEGER;
BEGIN
SELECT COUNT(*) INTO Trigger_pintor_asignado
FROM puede_rest
WHERE (pintor=:new.pintor) and (restaurador=:new.codigo);
IF pintor_asignado = 0
THEN
RAISE_application_error (-20001, 'No se puede, ese cuadro es de un
pintor
no asignado al restaurador');
END IF;
END;
/
CASO PRACTICO 2: Editorial de libros de texto escolar
CREATE TABLE VENDEDORES(

codigo VARCHAR2(10) NOT NULL,
correo VARCHAR2(50) NOT NULL,
NIF VARCHAR2(9) NOT NULL,
Nombre VARCHAR2(15) NOT NULL,
Apellidos VARCHAR2(30) NOT NULL,
tipo VARCHAR2(10) NOT NULL,
CONSTRAINT pk_vendedores PRIMARY KEY (codigo),
CONSTRAINT uk_vendedores1 UNIQUE (correo),
CONSTRAINT uk_vendedores2 UNIQUE (NIF),
CHECK (tipo IN ('contratado','promotor'))
);
CREATE TABLE CONTRATADOS(

modelo_coche VARCHAR2(15) NOT NULL,
categoria VARCHAR2(7) NOT NULL,
fecha_alta DATE NOT NULL,
fecha_baja DATE,
CONSTRAINT pk_contratados PRIMARY KEY (codigo),
CONSTRAINT fk_contratados FOREIGN KEY (codigo)
REFERENCES VENDEDORES ON DELETE CASCADE,
CHECK (categoria IN ('1','2','3')),

CHECK ('fecha_alta'<'fecha_baja')
);
CREATE TABLE PROMOTORES(

categoria VARCHAR2(1) NOT NULL,
contratado VARCHAR2(10) NOT NULL,
CONSTRAINT pk_promotores PRIMARY KEY (codigo),
CONSTRAINT fk_contratados1 FOREIGN KEY (codigo)
REFERENCES VENDEDORES ON DELETE CASCADE,
CONSTRAINT fk_contratados2 FOREIGN KEY (contratado) REFERENCES
CONTRATADOS,
CHECK (categoria IN ('A','B', 'C'))
);
CREATE TABLE DELEGACIONES(

correo VARCHAR2(50) NOT NULL,
CONSTRAINT uk_delegacion UNIQUE (correo),
CONSTRAINT pk_delegación PRIMARY KEY (nombre)
);
CREATE TABLE CENTROS(

titularidad VARCHAR2(10) NOT NULL,
delegacion VARCHAR2(11) NOT NULL,
calle VARCHAR2(20) NOT NULL,
num NUMBER(3) NOT NULL,
poblacion VARCHAR2(20) NOT NULL,
provincial VARCHAR2(20) NOT NULL,
CP NUMBER(5) NOT NULL,
CONSTRAINT pk_centros PRIMARY KEY (codigo),
CONSTRAINT fk_centros FOREIGN KEY (delegacion) REFERENCES
DELEGACIONES ON DELETE CASCADE
);
CREATE TABLE ASIGNADOS(

vendedor VARCHAR2(10) NOT NULL,
centro VARCHAR2(10) NOT NULL,
CONSTRAINT pk_asignados1 PRIMARY KEY (vendedor, centro),
CONSTRAINT fk_asignados1 FOREIGN KEY (vendedor)
REFERENCES VENDEDORES,
CONSTRAINT fk_asignados2 FOREIGN KEY (centro)
REFERENCES CENTROS
);
CREATE TABLE VISITAS (


dia DATE NOT NULL,
hora_ini DATE NOT NULL,
descripcion LONG NOT NULL,
hora_fin DATE,
total_gastos NUMBER (5,2) DEFAULT (0.00),
CONSTRAINT pk_visitas PRIMARY KEY (centro,dia,hora_ini),
CONSTRAINT fk_visitas FOREIGN KEY (centro)
REFERENCES CENTROS ON DELETE CASCADE,
CHECK (hora_ini<hora_fin)
);
CREATE TABLE VISITAS_VENDEDORES (

vendedor VARCHAR2(10) NOT NULL,
dia DATE NOT NULL,
CONSTRAINT pk_visitas_vendedores PRIMARY
KEY(vendedor,centro,dia,hora_ini),
CONSTRAINT fk_visitas_vendedores1 FOREIGN KEY (vendedor) REFERENCES
VENDEDORES,
CONSTRAINT fk_visitas_vendedores2 FOREIGN KEY (centro,dia,hora_ini)
REFERENCES VISITAS
);
CREATE TABLE GASTOS(

Codigo VARCHAR2(10) NOT NULL,
Precio NUMBER(10,2) NOT NULL,
Tipo VARCHAR2(15) NOT NULL,
Vendedor VARCHAR2(10) NOT NULL,
dia DATE NOT NULL,
CONSTRAINT pk_gastos PRIMARY KEY (codigo),
CONSTRAINT fk_gastos1 FOREIGN KEY (vendedor) REFERENCES VENDEDORES,
CONSTRAINT fk_gastos2 FOREIGN KEY (centro,dia,hora_ini) REFERENCES
VISITAS,
CHECK (tipo IN ('manutencion','transporte','alojamiento'))
);
CREATE TABLE TRANSPORTES (

medio VARCHAR2(7) NOT NULL,
Kms NUMBER(4) DEFAULT (0),
CONSTRAINT pk_transportes PRIMARY KEY (codigo),
CONSTRAINT fk_transportes FOREIGN KEY (codigo) REFERENCES GASTOS ON
DELETE CASCADE,
CHECK (medio IN ('coche','taxi','avion','tren','autobus','metro'))
);

CREATE TABLE MANUTENCIONES (

hora VARCHAR2(8) NOT NULL,
CONSTRAINT pk_manutenciones PRIMARY KEY (codigo),
CONSTRAINT fk_manutenciones FOREIGN KEY (codigo)
REFERENCES GASTOS ON DELETE CASCADE,
CHECK (hora IN ('desayuno','comida','cena'))
);
Para implementar la base de datos con todas sus restricciones en el SGBD
ORACLE, hay que añadir al script de creación expuesto, TRIGGER
A continuación se muestra el TRIGGER “Calculo_total_gastos” que actualiza la columna
“total_gastos” de la tabla VISITAS.
CREATE OR REPLACE TRIGGER Calculo_total_gastos

BEFORE INSERT OR UPDATE OF precio ON GASTOS FOR EACH ROW
BEGIN
IF INSERTING
THENUPDATE VISITAS
SET total_gastos = (VISITAS.total_gastos + :new.precio)
WHERE
(VISITAS.centro=:new.centro) AND
(VISITAS.dia =:new.dia) AND
(VISITAS.hora_ini =:new.hora_ini);
ELSIF UPDATING
THEN
UPDATE VISITAS
SET total_gastos = (VISITAS.total_gastos +:new.precio -
:old.precio)
WHERE
(VISITAS.centro =:new.centro) AND
(VISITAS.dia =:new.dia) AND
(VISITAS.hora_ini =:new.hora_ini);
END IF;
END;
/
Para controlar que un contratado supervisa como máximo a tres promotores, está el
siguiente TRIGGER, “Trigger_maximo_supervisiones”, que se ejecutará en la tabla
PROMOTORES cuando se inserte un nuevo vendedor promotor. Consulta la misma tabla
PROMOTORES. No permitirá realizar la operación en el caso de que el vendedor
contratado que se le quiera asignar como supervisor tenga ya tres promotores a
supervisar.
CREATE OR REPLACE TRIGGER Trigger_maximo_supervisiones
BEFORE INSERT ON PROMOTORES FOR EACH ROW
DECLARE
n_supervisiones INTEGER;
BEGIN
SELECT COUNT (*) INTO n_supervisiones
FROM PROMOTORES
WHERE (contratado =:new.contratado);

IF n_supervisiones>=3
THEN
RAISE_application_error (-20001, 'No se puede asignar este
Contratado como supervisor, ya esta supervisando ya a
tresvendedorespromotores');
END IF;
END;
/

Guía Consultas avanzadas en SQL5

Agrupaciones
Es muy común utilizar consultas en las que se desee agrupar los datos a fin de realizar
cálculos en vertical, es decir calculados a partir de datos de distintos registros.
Para ello se utiliza la cláusula GROUP BY que permite indicar en base a qué registros se
realiza la agrupación. Con GROUP BY la instrucción SELECT queda de esta forma:
En el apartado GROUP BY, se indican las columnas por las que se agrupa. La función de
este apartado es crear un único registro por cada valor distinto en las columnas del
grupo.
5
Fuente original: M2109 - Databases . Rafafel Camps Paré, Luís Alberto Casillas Santillán, Dolors Costal Costa, Marc
Gibert Ginestà, Carme Martín Escofet, Óscar Pérez Mora. Official Master in Free and Open Source Software Technology.
Open University of Catalonia
FUNCIONES DE CÁLCULO CON GRUPOS

Lo interesante de la creación de grupos es las posibilidades de cálculo que ofrece. Para
ello se utilizan funciones que permiten trabajar con los registros de un grupo son:
Función Significado
Cuenta los elementos de un grupo. Se utiliza el asterisco para
COUNT(*) no tener que indicar un nombre de columna concreto, el
resultado es el mismo para cualquier columna
SUM(expresión) Suma los valores de la expresión
AVG(expresión) Calcula la media aritmética sobre la expresión indicada
MIN(expresión) Mínimo valor que toma la expresión indicada
MAX(expresión) Máximo valor que toma la expresión indicada
STDDEV(expresión) Calcula la desviación estándar
VARIANCE(expresión) Calcula la varianza
CONDICIONES HAVING
A veces se desea restringir el resultado de una expresión agrupada
Se utiliza la cláusula HAVING, que se ejecuta una vez realizados los grupos.
El orden de ejecución de la consulta marca lo que se puede utilizar con WHERE y lo que
se puede utilizar con HAVING:
Para evitar problemas estos podrían ser los pasos en la ejecución de una instrucción de
agrupación por parte del gestor de bases de datos
- Seleccionar las filas deseadas utilizando WHERE. Esta cláusula eliminará columnas
en base a la condición indicada
- Se establecen los grupos indicados en la cláusula GROUP BY
- Se calculan los valores de las funciones de totales (COUNT, SUM, AVG,...)
- Se filtran los registros que cumplen la cláusula HAVING
- El resultado se ordena en base al apartado ORDER BY.
Subconsultas
USO DE SUBCONSULTAS SIMPLES
Se trata de una técnica que permite utilizar el resultado de una tabla SELECT en otra
consulta SELECT. Permite solucionar consultas que requieren para funcionar el resultado
previo de otra consulta.
La sintaxis es:
Se puede colocar el SELECT dentro de las cláusulas WHERE, HAVING o FROM. El

operador puede ser >,<,>=,<=,!=, = o IN.

Ejemplo:
SELECT nombre_empleado, paga FROM empleados
WHERE paga <
(SELECT paga FROM empleados WHERE nombre_empleado='Martina') ;
Lógicamente el resultado de la subconsulta debe incluir el campo que estamos
analizando. Se pueden realizar esas subconsultas las veces que haga falta:
SELECT nombre_empleado, paga FROM empleados WHERE paga <
(SELECT paga FROM empleados WHERE nombre_empleado='Martina') AND paga >
(SELECT paga FROM empleados WHERE nombre_empleado='Luis');
En realidad lo primero que hace la base de datos es calcular el resultado de la
subconsulta:
La última consulta obtiene los empleados cuyas pagas estén entre lo que gana Luís
(1870 euros) y lo que gana Martina (2500) .
Las subconsultas siempre se deben encerrar entre paréntesis y se debería colocar a la
derecha del operador relacional. Una subconsulta que utilice los valores >,<,>=,... tiene
que devolver un único valor, de otro modo ocurre un error. Además tienen que tener el
mismo tipo de columna para relacionar la subconsulta con la consulta que la utiliza (no
puede ocurrir que la subconsulta tenga dos columnas y ese resultado se compare
usando una sola columna en la consulta general).
USO DE SUBCONSULTAS DE MÚLTIPLES FILAS

En el apartado anterior se comentaba que las subconsultas sólo pueden devolver una
fila. Pero a veces se necesitan consultas del tipo: mostrar el sueldo y nombre de los
empleados cuyo sueldo supera al de cualquier empleado del departamento de ventas.
La subconsulta necesaria para ese resultado mostraría todos los sueldos del
departamento de ventas. Pero no podremos utilizar un operador de comparación
directamente ya que esa subconsulta devuelve más de una fila. La solución a esto es
utilizar instrucciones especiales entre el operador y la consulta, que permiten el uso de
subconsultas de varias filas.

Esas instrucciones son:

Instrucción Significado
Compara con cualquier registro de la subconsulta. La
ANY instrucción es válida si hay un registro en la subconsulta que
permite que la comparación sea cierta
Compara con todos los registros de la consulta. La instrucción
ALL resulta cierta si es cierta toda comparación con los registros de
la subconsulta
No usa comparador, ya que sirve para comprobar si un valor
IN
se encuentra en el resultado de la subconsulta
NOT IN Comprueba si un valor no se encuentra en una subconsulta
Ejemplo:
SELECT nombre, sueldo
FROM empleados
WHERE sueldo >= ALL (SELECT sueldo FROM empleados);
La consulta anterior obtiene el empleado que más cobra. Otro ejemplo:
SELECT nombre FROM empleados
WHERE dni IN (SELECT dni FROM directivos);
En ese caso se obtienen los nombres de los empleados cuyos dni están en la tabla de
directivos.
Si se necesita comprobar dos columnas en una consulta IN, se hace:
SELECT nombre FROM empleados
WHERE (cod1,cod2) IN (SELECT cod1,cod2 FROM directivos);
CONSULTAS EXISTS
Este operador devuelve verdadero si la consulta que le sigue devuelve algún valor. Si
no, devuelve falso. Se utiliza sobre todo en consultas correlacionadas
Normalmente las consultas EXISTS se pueden realizar de alguna otra forma con los
operadores ya comentados.
Combinaciones especiales
UNIONES
La palabra UNION permite añadir el resultado de un SELECT a otro SELECT. Para ello
ambas instrucciones tienen que utilizar el mismo número y tipo de columnas. Ejemplo:
SELECT nombre FROM provincias UNION SELECT nombre FROM comunidades
El resultado es una tabla que contendrá nombres de provincia y de comunidades. Es
decir, UNION crea una sola tabla con registros que estén presentes en cualquiera de las
consultas. Si están repetidas sólo aparecen una vez, para mostrar los duplicados se
utiliza UNION ALL en lugar de la palabra UNION.
Es muy importante señalar que tanto ésta cláusula como el resto de combinaciones
especiales, requieren en los dos SELECT que unen el mismo tipo de columnas (y en el
mismo orden).

INTERSECCIONES
De la misma forma, la palabra INTERSECT permite unir dos consultas SELECT de modo
que el resultado serán las filas que estén presentes en ambas consultas.
Ejemplo; tipos y modelos de piezas que se encuentren sólo en los almacenes 1 y 2:
SELECT tipo,modelo FROM existencias WHERE n_almacen=1
INTERSECT
SELECT tipo,modelo FROM existencias WHERE n_almacen=2
DIFERENCIA
Con MINUS también se combinan dos consultas SELECT de forma que aparecerán los
registros del primer SELECT que no estén presentes en el segundo.
Ejemplo; tipos y modelos de piezas que se encuentren el almacén 1 y no en el 2
(SELECT tipo,modelo FROM existencias WHERE n_almacen=1)
MINUS(SELECT tipo,modelo FROM existencias WHERE n_almacen=2)
Se podrían hacer varias combinaciones anidadas (una unión cuyo resultado se
intersectará con otro SELECT por ejemplo), en ese caso es conveniente utilizar
paréntesis para indicar qué combinación se hace primero:
(SELECT... ....
UNION
SELECT...
...
)
MINUS
SELECT.... /* Primero se hace la unión y luego la diferencia*/
Consultas avanzadas
CONSULTAS CON ROWNUM
La función ROWNUM devuelve el número de la fila de una consulta. Por ejemplo en:
SELECT ROWNUM, edad, nombre FROM clientes
Aparece el número de cada fila en la posición de la tabla. Esa función actualiza sus
valores usando subconsultas de modo que la consulta:
SELECT ROWNUM AS ranking, edad, nombre FROM clientes
FROM (SELECT edad, nombre FROM clientes ORDER BY edad DESC)
Puesto que la consulta SELECT edad, nombre FROM clientes ORDER BY edad DESC,
obtiene una lista de los clientes ordenada por edad, el SELECT superior obtendrá esa
lista pero mostrando el orden de las filas en esa consulta. Eso permite hacer consultas el
tipo top-n, (los n más....).
Por ejemplo para sacar el top-10 de la edad de los clientes (los 10 clientes más
mayores):
SELECT ROWNUM AS ranking, edad, nombre FROM clientes
FROM (SELECT edad, nombre FROM clientes ORDER BY edad DESC)
WHERE ROWNUM<=10

CONSULTAS SOBRE ESTRUCTURAS JERÁRQUICAS

Imaginemos una tabla de empleados definida por un código de empleado, nombre del
mismo y el código del jefe. Este último código está relacionado con el código de
empleado que posee el jefe en cuestión. Así definido, una consulta que muestre el
nombre de un empleado y el nombre de su jefe directo, sería:
SELECT e.nombre AS empleado, j.nombre AS jefe
FROM empleados e
JOIN empleados j ON (e.cod_jefe=j.cod_empleado);
Saldría por ejemplo:
En el ejemplo se observa como un jefe puede tener otro jefe, generando una estructura
jerárquica:
En este tipo de estructuras, a veces se requieren consultas que muestren todos los
empleados de un jefe, mostrando los mandos intermedios. Se trata de una consulta que
recorre ese árbol. Este tipo de consultas posee esta sintaxis:
El apartado CONNECT permite indicar qué relación hay que seguir para recorrer el
árbol. La palabra PRIOR indica hacia dónde se dirige el recorrido. Finalmente el
apartado START indica la condición de inicio del recorrido (normalmente la condición
que permita buscar el nodo del árbol por el que comenzamos el recorrido, es decir sirve
para indicar desde donde comenzamos.
Ejemplo:
SELECT nombre FROM empleados START WITH nombre='Andrés'
CONNECT BY PRIOR n_jefe=n_empleado;

Resultado:
Sin embargo:
SELECT nombre FROM empleados START WITH nombre='Andrés'
CONNECT BY n_jefe= PRIOR n_empleado;
Devuelve
Si en lugar de Andrés en esa consulta buscáramos desde Ángel, saldría:
El modificador LEVEL permite mostrar el nivel en el árbol jerárquico de cada elemento:

SELECT LEVEL, nombre FROM empleados
START WITH nombre='Ángel' CONNECT BY n_jefe= PRIOR n_empleado;
Resultado:
Para eliminar recorridos, se utilizan condiciones en WHERE o en el propio CONNECT. De
modo que :
SELECT LEVEL, nombre FROM empleados WHERE nombre!='Eva'

START WITH nombre='Ángel' CONNECT BY n_jefe= PRIOR n_empleado;
En ese ejemplo, Eva no sale en los resultados. En este otro:
SELECT LEVEL, nombre FROM empleados START WITH nombre='Ángel'
CONNECT BY n_jefe= PRIOR n_empleado AND nombre!='Eva';
No sale ni Eva ni sus empleados (se corta la rama entera).

Cuando los datos forman un árbol jerárquico (como ocurre con los ejemplos) no suele
haber ningún problema. Pero hay diseños en los que hay padres de hijos que a su vez
pueden ser sus padres. Con los padres e hijos no ocurre esta situación evidentemente.
Pero por ejemplo si tuviéramos un diseño de redes sociales donde se apunta el nombre
del usuario y el nombre de sus amigos, entonces resulta que yo estaré apuntado como
amigo de una persona que, a su vez, es mi amigo.
En ese caso resultaría un bucle infinito cuando se hace esta consulta:
SELECT amigo FROM contactos
START WITH nombre='Ángel'
CONNECT BY PRIOR amigo=nombre;
-- Ocurre un bucle imposible de solucionar
Para esos casos disponemos de la cláusula NOCYCLE que controla los resultados
repetidos y evita esos caminos. En cualquier caso consultas en datos no jerarquizados
en forma de árbol sino en forma de grafo (como el comentado ejemplo de las redes
sociales), pueden ocupar muchísimo tiempo a Oracle por lo que no es mala idea pensar
en otra solución con ayuda de PL/SQL (lenguaje que se comenta en estos mismos
apuntes).
SELECT DISTINCT amigo FROM contactos
START WITH nombre='Ángel'
CONNECT BY NOCYCLE PRIOR amigo=nombre; -- Ahora sí
Por cierto, el DISTINCT impide que aparezcan muchas veces las mismas personas. Ya
que pueden ser amigos de muchos de mis amigos (e incluso de muchos de los amigos
de mis amigos).
Consultas de agrupación avanzada

ROLLUP
Esta expresión en una consulta de agrupación (GROUP BY) permite obtener los totales
de la función utilizada para calcular en esa consulta. Ejemplo:
SELECT tipo, modelo, SUM(cantidad) FROM existencias GROUP BY tipo,modelo;
Esta consulta suma las distintas cantidades de la tabla existencias por cada tipo y
modelo Si añadimos:
SELECT tipo, modelo, SUM(cantidad) FROM existencias
GROUP BY ROLLUP (tipo,modelo);
Entonces nos añade un registro para cada tipo en el que aparece la suma del total para
ese tipo. Al final mostrará un registro con el total absoluto. Es decir el resultado de esa
consulta es:
Se pueden unir varias columnas entre paréntesis para tratarlas como si fueran una
unidad:
SELECT tipo, modelo, n_almacen, SUM(cantidad) FROM existencias
GROUP BY ROLLUP ((tipo,modelo), (n_almacen));
La diferencia respecto a la anterior es que el total mostado por ROLLUP se referirá al
tipo y al modelo.

CUBE
Es muy similar al anterior, sólo que este calcula todos los subtotales relativos a la
consulta. Ejemplo:
SELECT tipo, modelo, SUM(cantidad) FROM existencias
GROUP BY CUBE (tipo,modelo);
Es decir, calcula totales por tipo, por modelo y el total absoluto.
GROUPING
Se trata de una función que funciona con ROLLUP y CUBE y que recibe uno o más
campos e indica si la fila muestra un subtotal referido a los campos en cuestión. Si la fila
es un subtotal de esos campos pone 1, sino lo marca con 0. Ejemplo:
SELECT tipo, modelo, SUM(cantidad),
GROUPING(tipo), GROUPING(modelo) FROM existencias GROUP BY CUBE
(tipo,modelo);
Se utiliza sobre todo para preparar un consulta para la creación de informes.
GROUPING SETS
Se trata de una mejora de Oracle 9i que permite realizar varias agrupaciones para la
misma consulta. Sintaxis:
SELECT...
...
GROUP BY GROUPING SETS (listaDeCampos1) [,(lista2)...]
Las listas indican los campos por los que se realiza la agrupación. Ejemplo:
GROUP BY GROUPING SETS ((tipo,modelo), (n_almacen));
Se trata de dos consultas de totales unidades
CONJUNTOS DE AGRUPACIONES COMBINADAS
Se pueden combinar agrupaciones de diversas formas creando consultas como:
GROUP BY tipo, ROLLUP(modelo), CUBE(n_almacen)
Que mostraría un informe espectacular sobre las tablas anteriores. Así como:
SELECT tipo, modelo,n_almacen, SUM(cantidad) FROM existencias
GROUP BY GROUPING SETS(tipo,modelo), GROUPING SETS(tipo,n_almacen)
DQL en instrucciones DML

Se trata de cómo utilizar instrucciones SELECT dentro de las instrucciones DML
(INSERT, DELETE o UPDATE), ello permite dar más potencia a dichas instrucciones.
RELLENO DE REGISTROS A PARTIR DE FILAS DE UNA CONSULTA
Hay un tipo de consulta, llamada de adición de datos, que permite rellenar datos de una
tabla copiando el resultado de una consulta. Se hace mediante la instrucción INSERT y,
en definitiva, permite copiar datos de una consulta a otra.

Ese relleno se basa en una consulta SELECT que poseerá los datos a añadir.
Lógicamente el orden de esos campos debe de coincidir con la lista de campos indicada
en la instrucción INSERT.
Sintaxis:
Ejemplo:
INSERT INTO clientes2004 (dni, nombre, localidad, direccion)
SELECT dni, nombre, localidad, direccion FROM clientes WHERE problemas=0;
Lógicamente las columnas del SELECT se tienen que corresponder con las columnas a
rellenar mediante INSERT (observar las flechas).
SUBCONSULTAS EN LA INSTRUCCIÓN UPDATE
La instrucción UPDATE permite modificar filas. Es muy habitual el uso de la cláusula
WHERE para indicar las filas que se modificarán. Esta cláusula se puede utilizar con las
mismas posibilidades que en el caso del SELECT, por lo que es posible utilizar
subconsultas. Por ejemplo:
UPDATE empleados SET sueldo=sueldo*1.10
WHERE id_seccion =(SELECT id_seccion FROM secciones
WHERE nom_seccion='Producción');
Esta instrucción aumenta un 10% el sueldo de los empleados de la sección llamada
Producción. También podemos utilizar subconsultas en la cláusula SET de la instrucción
UPDATE.
Ejemplo:
UPDATE empleados SET puesto_trabajo=(SELECT puesto_trabajo
FROM empleados
WHERE id_empleado=12)
WHERE seccion=23;
Esta instrucción coloca a todos los empleados de la sección 23 el mismo puesto de
trabajo que el empleado número 12. Este tipo de actualizaciones sólo son válidas si el
subselect devuelve un único valor, que además debe de ser compatible con la columna
que se actualiza.
Hay que tener en cuenta que las actualizaciones no pueden saltarse las reglas de
integridad que posean las tablas.
SUBCONSULTAS EN LA INSTRUCCIÓN DELETE
Al igual que en el caso de las instrucciones INSERT o SELECT, DELETE dispone de
cláusula WHERE y en dicha cláusulas podemos utilizar subconsultas. Por ejemplo:
DELETE empleados WHERE id_empleado IN
(SELECT id_empleado FROM errores_graves);
En este caso se trata de una subconsulta creada con el operador IN, se eliminarán los
empleados cuyo identificador esté dentro de la tabla de errores graves.

Introducción al SQL procedimental

Casi todos los grandes Sistemas Gestores de Datos incorporan utilidades que permiten
ampliar el lenguaje SQL para producir pequeñas utilidades que añaden al SQL mejoras
de la programación estructurada (bucles, condiciones, funciones,....). La razón es que
hay diversas acciones en la base de datos para las que SQL no es suficiente.
Por ello todas las bases de datos incorporan algún lenguaje de tipo procedimental (de
tercera generación) que permite manipular de forma más avanzada los datos de la base
de datos.
PL/SQL es el lenguaje procedimental que es implementado por el precompilador de
Oracle. Es una extensión procedimental del lenguaje SQL; es decir, se trata de un
lenguaje creado para dar a SQL nuevas posibilidades. Esas posibilidades permiten
utilizar condiciones y bucles al estilo de los lenguajes de tercera generación (como Basic,
Cobol, C++, Java, etc.). En otros sistemas gestores de bases de datos existen otros
lenguajes procedimentales: SQL Server utiliza Transact SQL, Informix usa Informix
4GL,...
Lo interesante del lenguaje PL/SQL es que integra SQL por lo que gran parte de su
sintaxis procede de dicho lenguaje. PL/SQL es un lenguaje pensado para la gestión de
datos. La creación de aplicaciones sobre la base de datos se realiza con otras
herramientas (Oracle Developer) o lenguajes externos como Visual Basic o Java. El
código PL/SQL puede almacenarse:
- En la propia base de datos
- En archivos externos
FUNCIONES QUE PUEDEN REALIZAR LOS PROGRAMAS
Las más destacadas son:
- Facilitar la realización de tareas administrativas sobre la base de datos (copia de
valores antiguos, auditorías, control de usuarios,…)
- Validación y verificación avanzada de usuarios
- Consultas muy avanzadas
- Tareas imposibles de realizar con SQL
CONCEPTOS BÁSICOS
- Bloque PL/SQL Se trata de un trozo de código que puede ser interpretado por
Oracle. Se encuentra inmerso dentro de las palabras BEGIN y END.
- Programa PL/SQL Conjunto de bloques que realizan una determinada labor.
- Procedimiento Programa PL/SQL almacenado en la base de datos y que puede ser
ejecutado si se desea con solo saber su nombre (y teniendo permiso para su acceso).
- Funciónm Programa PL/SQL que a partir de unos datos de entrada obtiene un
resultado (datos de salida). Una función puede ser utilizada desde cualquier otro
programa PL/SQL e incluso desde una instrucción SQL.
- trigger (disparador) Programa PL/SQL que se ejecuta automáticamente cuando
ocurre un determinado suceso a un objeto de la base de datos.
- Paquete Colección de procedimientos y funciones agrupados dentro de la misma
estructura. Similar a las bibliotecas y librerías de los lenguajes convencionales.

Optimización de consultas
Considere el siguiente esquema:
CLIENTE {cli_id, cli_nom, cli_renta_anual, cli_tipo}
CAMION {cam_id, cam_nombre_chofer}
CIUDAD {ciu_nombre, ciu_poblacion}
EMBARQUE {emb_id, emb_cli_id, emb_peso, emb_camion_id, emb_destino,
emb_fecha}
Clave foránea: emb_cli_id referencia a cli_id en CLIENTE
Clave foránea: emb_destino referencia a ciu_nombre en ciudad
Clave foránea: emb_id_camion referencia a cam_id en CAMION
Considere además los siguientes tamaños de las tablas:
CLIENTE: 200 registros
CAMION: 30 registros
CIUDAD: 30 registros
EMBARQUE: 7000 registros
Optimice la consulta: Cómo se llaman los clientes que han enviado paquetes a
Antofagasta.
En SQL la consulta sería:
SELECT cli_nom
FROM CLIENTE, EMBARQUE
WHERE cli_id = emb_cli_id AND emb_destino = ‘Antofagasta’
Pasando a álgebra relacional, la consulta es:
Para esto, se debe inspeccionar registros,

aunque no necesariamente almacenamos esta cantidad de registros pues al hacer join
(cli_id = emb_cli_id) se eliminan muchas combinaciones.
Suponiendo que los embarques a Antofagasta son aproximadamente 1000, tenemos un
número considerable de tuplas a inspeccionar, probemos optimizar esto.
Consideramos las siguientes reglas de optimización:
[1] Hacer las selecciones y proyecciones lo antes posible.
[2] Preprocesar los datos antes de hacer un join o un producto cartesiano, para esto se
puede ordenar o usar/construir índices.
[3] Buscar sub-expresiones comunes, que nos permitan realizar factorizaciones o
mantener resultados parciales, que se utilizarán muchas veces, ya sea en memoria
(si son pequeños) o en disco.
[4] Hacer selecciones y proyecciones en cascada.
También debemos tener en cuenta lo siguiente:
- Las selecciones reducen el rango de las tuplas que debemos inspeccionar, y las
proyecciones reducen el tamaño de la tupla al tamaño de las componentes que nos
interesan.
- Existe la conmutatividad de los operadoes de join y de producto cartesiano.

- La consulta optimizada no necesariamente es la “óptima”, sino una aproximación a

una solución más eficiente que la original y, con seguridad, encontrarla es menos
costosa que la solución óptima.
Volvamos entonces a la consulta de interés:
a) Podemos pasar la selección de emb_destino = ‘Antofagasta’ para que opere sobre la

tabla EMBARQUE y no sobre el producto cartesiano (por regla [1]).
b) Además, basta con considerar las componentes emb_cli_id y emb_destino
deEMBARQUE, y luego de esto hacer la selección emb_destino = ‘Antofagasta’ (por
regla [2]).
Con a) y b) nos queda lo siguiente:
c) Para hacer el join, necesitamos cli_id y emb_cli_id. Además necesitamos el atributo

cli_nom para la proyección de cli_nom más externa (por regla [1]).
Con c) obtenemos:
Notar que con este manejo de proyecciones y selecciones, reducimos la cantidad de

tuplas y atributos a inspeccionar, lo que nos permite hacer la consulta con un menor uso
de memoria.
Ahora veamos como manejamos el join. Existen varias posibilidades:
- Fuerza bruta.
- Join Merge. Ordenamos los dos conjuntos según el atributo con el que se hace el join,
yluego verificamos en orden cuando se tenga el calce. Con esto pagamos el costo de
las ordenaciones de ambos conjuntos, más el recorrido secuencial por ambos conjun
tos ordenados.
- Uso de índices. Si tenemos un conjunto indezado y el otro no, recorremos el conjunto
NO indexado, y para cada valor, utilizamos el índice para encontrar el
correspondiente en el otro conjunto, con esto hacemos un recorrido secuencial del
conjunto no indexado, y en el indexado accedemos a los valores gracias al índice. Si
los dos conjuntos están indexados, hacemos lo mismo (recorrimos secuencialmente
un conjunto y con el índice del otro conjunto recuperamos el valor correspondiente).

A. Práctica: Consultas con Sql

1. Realizar una Base de Datos para controlar el movimiento de una
UNIVERSIDAD.
Debes entregar al final de la sesión los códigos de estas consultas siguiendo las
instrucciones que se dan al final de este ejercicio.
Dada las siguientes tablas del relacional normalizado de una base de datos llamada
UNIVERSIDAD:
DATOSALUMNO
RUT NOMBRE DIRECCION TELEFONO
12345 Julio Escudero El sauce 134 4563215
32456 Ignacio Ampuero Violetas 445 6556554
67899 Daniela Torres Los andes 23 3225222
78654 Tania Torres Tucanes 456 8856877
34321 Julio Cruz Los alpes 78 5552355
ASIGNATURAALUMNO
RUT CODIGO A
12345 B01
12345 B02
32456 C03
32456 B03
32456 B01
67899 B03
78654 B01
78654 B02
34321 B03
34321 C03
Obs: la cardinalidad de datosalumnos datosasignatura es 1:N
PROFESOR
CODIGOP NOMBRE DEPARTAMETO TELEFONO CODIGO A
11001 Mauricio Cid Informática 6554337 B01
11002 Rosa Barrera Informática 5565667 B02
11003 Marlene Cruz Idioma 7878666 C03
11004 Jose Orellana Informatica 7689555 B03
DATOSASIGNATURA
CODIGOA NOMBRE JORNADA CREDITOS
B01 Base de datos Diurna 4
B02 Informática Diurna 6
C03 Ingles Vespertina 6
B03 Programación Vespertina 5

I. Realice las siguientes actividades en una base de datos de Mysql:

a. Crear la base de datos UNIVERSIDAD.
b. Crear las tablas propuestas.
c. Guardar los Scripts de creación de la base de datos.
d. Insertar 4 tuplas por tabla.
e. Realizar 10 consultas multitabla a la base de datos creada con encabezados en un
archivo .txt
f. Escribir los códigos SQL de las consultas y entregarlos en un fichero denominado
consultasMySQL.sql siguiendo el siguiente formato:
/* grupo i
Nombres */
/* Consulta N1 */
SELECT …
FROM …
…
;
…
/* Consulta N5 */
SELECT …
…
;
II. Realice las siguientes actividades en una bas de datos de Oracle 10g:
a. Crear las tablas de la base de datos.
b. Insertar 4 tuplas por tabla.
c. Realizar 10 consultas multitabla a la base de datos creada con encabezados en un
archivo .txt
d. Escribir los códigos SQL de las consultas y entregarlos en un fichero denominado
consultasOracle.sql

2. Se dispone de una Base de Datos en la que figuran tramos de comunicación

por carretera entre localidades de España.
De las localidades se tiene: código de localidad, nombre de la localidad, número de
habitantes censados oficialmente y número de habitantes que realmente residen en la
localidad. De las provincias se tiene el código de la provincia, el nombre de la provincia y
el nombre de la comunidad autónoma a la que pertenece. De cada tramo se almacena
las dos localidades o nodos relacionados y la distancia entre ellos.
Obtenemos el siguiente diseño lógico estándar:
PROVINCIAS ( Codprov, NombreP, Comunidad )
LOCALIDADES ( CodLoc, NombreL, censo, Habitantes, CodProv )
TRAMOS (CodLocA, CodLocB, Distancia)
Pasaremos ahora a especificar el diseño lógico específico conducente a la creación de la
base de datos (el SGBDR elegido para ello ha sido DB2).
CREATE DATABASE Tramos;
CREATE DOMAIN EnteroPositivo INTEGER CHECK (VALUE > 0);
CREATE TABLE Provincias
( CodProv CHAR(2) NOT NULL,
NombreP CHAR(30) NOT NULL,
Comunidad CHAR(20) NOT NULL,
PRIMARY KEY (CodProv) );
CREATE TABLE Localidades
( CodLoc CHAR(3) NOT NULL,
NombreL CHAR(30) NOT NULL,
Censo EnteroPositivo,
Habitantes EnteroPositivo,
CodProv CHAR(2) NOT NULL,
PRIMARY KEY (CodLoc) );
CREATE TABLE Tramos
( CodLoc_A CHAR(3) NOT NULL,
CodLoc_B CHAR(30) NOT NULL,
Distancia DECIMAL(3,2) NOT NULL CHECK (VALUE > 0),
PRIMARY KEY (CodLoc_A, CodLoc_B) );
ALTER TABLE Localidades ADD FOREIGN KEY (CodProv) REFERENCES Provincias
(CodProv);
ALTER TABLE Tramos ADD CONSTRAINT localidadesA_fk
FOREIGN KEY (CodLoc_A) REFERENCES Localidades (CodLoc);
ALTER TABLE Tramos ADD CONSTRAINT localidadesB_fk
FOREIGN KEY (CodLoc_B) REFERENCES Localidades (CodLoc);
Como datos iniciales partimos de los siguientes:

Se pide:
1. Obtener el nombre de la comunidad autónoma con menor número de habitantes.
2. Obtener el nombre de las comunidades autónomas con un número de habitantes por
debajo de la media de todas las comunidades.
3. Obtener el nombre de las localidades con un número de habitantes por debajo de la media
de todas las localidades.
4. Obtener las localidades accesibles a través de un solo tramo desde la localidad de Cuenca.
5. Obtener el nombre de las localidades de la comunidad autónoma CLM.
6. Obtener el número de habitantes de cada provincia, ordenando por comunidad autónoma
y provincia.
7. Obtener las comunidades autónomas que tienen de media una distancia superior a 30
kilómetros entre las localidades de su comunidad.
8. Nombre de las provincias con un censo inferior a 40000 habitantes.
9. Obtener localidades que no figuren en ninguno de los tramos o en los que no figure la
distancia entre los nodos del tramo.
10. Escribir los códigos SQL de las consultas y entregarlos en un fichero denominado
consultasDB2.sql.

3. Consultar una Base de Datos para controlar el movimiento de una

BIBLIOTECA.
La Base de Datos estará compuesta por tres tablas: SOCIOS, LIBROS y PRÉSTAMOS.
Las características de cada una de las tablas se muestran a continuación:

A partir de la base de datos “BIBLIO” que contiene información sobre los libros de
una biblioteca, realizar las siguientes consultas.
11. Nombre, dirección y teléfono de las editoriales de Nueva York (New York).
12. Nombre, dirección y teléfono de las editoriales del estado Massachusetts (MA).
13. Nombre y año de nacimiento de los escritores nacidos antes de 1950.
14. Nombre de los escritores de los que no se conoce el año de nacimiento.
15. Título de los libros publicados por editoriales de Boston después de 1990.
16. Nombre, dirección y teléfono de las editoriales con número de teléfono que empiece por
2.
17. Nombre completo de los escritores que se llamen Michael.
18. Título y año de publicación de los libros publicados recientemente (desde 1995) y que
contengan la palabra “Access” en su titulo.
19. Título y año de publicación de los libros escritos por un autor determinado.
20. Título y año de publicación de los libros publicados por una determinada editorial (indicad
el nombre de la compañía).
21. Cread una consulta con los campos autor y año de nacimiento de la tabla autores
mostrando solo aquellos que tienen año de nacimiento. Añadid un campo que calcule la
edad actual de los autores.
22. Realizad una consulta similar para conocer los años que llevan publicados los libros.
23. Calculad cuál es el año de publicación de los libros más reciente.
24. Calculad la media de edad de los autores.
25. ¿Cuál es el año de publicación más antiguo? A partir de este dato mostrad los libros más
antiguos.
Escribir por cada punto la sentencia sql y la tabla resultado
4. Realizaruna Base de Datos para controlar el movimiento de un VIDEOCLUB.

La Base de Datos estará compuesta por las tablas que se presentan a continuación:


A partir de la base de datos “Videoclub” realizar las siguientes tareas con las tablas
en Vista Hoja de Datos:
1. Ordenar por ...
- año de estreno la tabla Películas.
- título de películas la tabla Dvd.
- nombre la tabla de Clientes.
- DNI del cliente la tabla Alquiler.
2. Filtros: (Antes de aplicar cada filtro elimina el anterior)
- Mostrar todas las comedias en la tabla películas.
- Mostrar los dramas del año 2000 en la tabla películas.
- Mostrar las películas dirigidas por Vicente Aranda.
- Mostrar los alquileres de 4,00 €.
- Mostrar los alquileres de 3,00 € del cliente con DNI 33333333C .
3. Buscar registros:
En la tabla películas buscar ...
- directores que se llamen Pedro.
- directores o intérpretes que se llamen Alex.
En la tabla clientes buscar la palabra SE en cualquier campo.
4. Modificar el formato de la Hoja de Datos:
- Cambiar las propiedades del texto y de la cuadrícula de cada una de las tablas.
5. Ident-Dvd y título de los dvd sin devolver (Fecha devolución = nulo).
6. DNI, nombre, dirección, teléfono y correo electrónico de los clientes que han alquilado
algún dvd el año 2001. (Cuidado que el campo fecha de alquiler es de tipo fecha).
7. Título de los dramas del 1999, comedias de 1997 y de todas las películas del 2001.
8. Nombre de los clientes que han alquilado una película que se estrenó en 1997. Incluid
también el título de la película.
9. Ident-dvd y título de los dvd alquilados por cliente en concreto (solicitad el DNI). Incluid
también la fecha de alquiler y devolución.
10. Nombre, dirección y teléfono de los clientes que han alquilado cierto Dvd.
11. Ident-dvd y título de los dvd sin devolver de un cliente concreto (solicitad el DNI). Incluid
también la fecha de alquiler.
12. Ident-dvd y título de los dvd de un género determinado.
13. ¿Cuántos alquileres de 3,00€ se han realizado?
14. ¿Cuántos dvd hay disponibles?
15. ¿Cuántas películas hay de género drama estrenadas en el 1998?
16. Calculad la media del precio de alquiler.
17. Cread una consulta con los campos Ident-dvd, nombre y apellidos del cliente. Añadid un
campo que muestre los días que el cliente tiene la película en su poder.
18. Actualización del precio de películas de 1998: Reducción del 10%.
19. Creación de una tabla con las películas vistas por los clientes.
20. Eliminar todos los datos de un cliente.
21. Presentar una consulta de tablas de referencias cruzadas que muestre el número de
películas de cliente por día.
22. Copiar la tabla alquileres y posteriormente realizar una consulta de datos anexados que
anexe esta copia a la original.
Escribir por cada punto la sentencia sql y la tabla resultado

Actividad EXTRA, Complementaria (no hay entregas)

MANUAL DE DESARROLLO DE APLICACIONES CON DEVELOPER DE ORACLE6
a. Introducción a las herramientas de Developer

Developer es un conjunto de herramientas de desarrollo de Oracle para la creación de
formularios, informes, gráficos, consultas, esquemas y procedimientos, y lo mejor de
todo, es que la programación se realiza a través de una interfaz gráfica declarativa, por
lo que se minimiza la escritura de código
Conceptos básicos Un proyecto es un conjunto de enlaces a los archivos que forman
su aplicación. En un proyecto podrá definir editores, compiladores y otras herramientas
que necesite en su proyecto.
Project Builder ayuda a organizar y mantener los distintos archivos de los que consta
una aplicación. Además, puede utilizar las herramientas que desees a través esta
herramienta, lo que facilita el proceso de desarrollo y documentación de su aplicación
El Asistente para proyectos (Project Wizard) proporciona una forma sencilla y rápida de
crear un proyecto. Este asistente se utiliza para crear un archivo de registro del
proyecto, en el que se guardan los archivos asociados a la aplicación. El asistente le guía
a través de una serie de pasos, en los que indicará si se trata de un proyecto nuevo o se
trata de un subproyecto, denominará a su proyecto, le asignará un directorio y
especificará una conexión por omisión. Una vez completados estos pasos, ya podrá
añadir los archivos que desee.
Form Builder es una herramienta de desarrollo de aplicaciones que permite a los
usuarios acceder a los datos guardados en la base de datos. En Form Builder se puede
trabajar con tres tipos de módulos: formularios, menús y librerías. Un formulario es un
conjunto de objetos y datos con los que interactúan los usuarios para manipular la base
de datos. Un módulo de menú está formados por menús y código para estos menús, y
los usuarios seleccionarán elementos del menú para realizar ciertas operaciones sobre la
aplicación. Un módulo de librería es un código del cliente que puede ser compartido por
varios módulos y aplicaciones.
El Explorador de objetos (Object Navigator) proporciona una vista jerárquica de los
objetos de la aplicación. El Asistente para bloques de datos (Data Block Wizard) le
permite crear o modificar fácilmente los bloques de su aplicación.
Las Librerías de objetos (Object Libraries) proporcionan un método sencillo para la
reutilización de objetos y ayudan al seguimiento de estándares dentro del equipo de
desarrollo. El Asistente de presentación (Layout Wizard) le permite organizar de forma
sencilla los elementos de un bloque de datos. El asistente muestra los elementos en un
marco (frame) o en un lienzo (canvas) y permite visualizarlos de acuerdo con varios
estilos que posteriormente podrá personalizar.
El Cuadro de Propiedades (Property Palette) le permite configurar propiedades de los
objetos de un módulo de un formulario o un menú.
6 Manuel Torres Gil. Departamento de Lenguajes y Computación. Universidad de Almera. Asignatura Web de Bases de datos
(ITIG) página 42 de Práctica 3. Desarrollo de bases de datos con ORACLE (http://indalog.ual.es/mtorres/BD/bdp3.pdf)

El Cuadro de Propiedades se actualiza automáticamente cada vez que se selecciona un

objeto en el Explorador de objetos. El Editor integrado de PL/SQL le permite escribir
código PL/SQL desde Form Builder. Ofrece una interfaz gráfica para la edición y
depuración de funciones y procedimientos cliente/servidor. Graphics Builder le permite
generar gráficos dinámicos que representen gráficamente los datos y ayuden a una
mejor comprensión visual.
Una aplicación creada con Graphics Builder se denomina display. Un display contiene
todos los componentes que se utilizan en la aplicación, incluyendo las definiciones de los
orígenes de datos, los elementos visuales y su comportamiento. Cada display tiene un
esquema, sobre el que se crean los objetos gráficos. El esquema consiste en una o
varias capas que contienen los distintos elementos del display.
Una vez que esté ejecutando el display podrá ocultar, mostrar y organizar estas capas
de forma que el usuario pueda obtener distintas vistas. También son parte de los
displays las construcciones PL/SQL y las consultas en las que están basados los displays.
Hay unos cincuenta tipos de gráficos definidos, y además puede utilizar un conjunto de
herramientas de dibujo para la creación de displays personalizados, como puede ser un
mapa interactivo. Los gráficos se pueden modificar con el Editor de presentación (Layout
Editor). El Explorador de objetos (Object Navigator) proporciona una representación
jerárquica de los objetos del display.
El Asistente para gráficos (Chart Wizard) le permite crear fácilmente un gráfico,
seleccionar una fuente de datos, y crear una consulta para especificar los datos que hay
que representar en el gráfico.
El Cuadro de Propiedades (Property Palette) le permite configurar las propiedades de los
objetos de los displays, y se actualiza automáticamente cada vez que se selecciona un
objeto en el Explorador de objetos.
Report Builder le permite crear informes de calidad en un entorno cliente/servidor o en
un entorno Web. Los informes pueden ser independientes o estar incluidos en
formularios o displays del Graphic Builder.
Un informe es una colección de objetos que definen sus datos, aspecto e interfaz. Para
crear un informe se utiliza el Asistente de informes (Report Wizard). Este asistente le
guía en el proceso de selección de un tipo de informe, definición del origen de los datos
y configuración de la presentación.
Una vez que termine con el Asistente de informes, el informe aparecerá en el
Visualizador (Live Previewer). El Visualizador es una herramienta de edición WYSIWYG
para facilitar las tareas de modificación del aspecto del informe. Para generar una salida
HTML o PDF de su informe utilice el Asistente para Web (Web Wizard).
Para ejecutar informes dinámicamente en un cliente Web, se utiliza el Servidor de
informes (Reports Server) junto con el Reports Web Cartridge o el Web CGI. Estos
últimos le permiten enviar a su servidor Web enviar sus peticiones para ejecutarlas y
recibir los resultados en el cliente.
Procedure Builder es un entorno integrado de desarrollo y mantenimiento de código para
aplicaciones cliente/servidor. Procedure Builder proporciona una interfaz gráfica para la
creación, edición y compilación de código PL/SQL en el cliente y en el servidor.

El Explorador de objetos proporciona una representación jerárquica de los objetos que

forman el procedimiento (unidades de programa, librerías y disparadores).
El Editor de unidades de programa (Program Unit Editor) proporciona un entorno de
edición para el código de su procedimiento, donde podrá compilar y depurar código
PL/SQL.
El Editor de disparadores (Database Trigger Editor) de la base de datos proporciona una
interfaz gráfica para la creación de disparadores de la base de datos.
El Intérprete (Interpreter) es el lugar donde podrá depurar y probar unidades de
programa simulando su comportamiento. En el Intérprete podrá utilizar puntos de
ruptura para detener la ejecución de una unidad de programa, de forma que pueda
depurar su código.
Las Librerías son conjuntos de unidades de programa que puede guardar en el cliente o
en el servidor para su posterior reutilización por otras aplicaciones. Las librerías
aumentan el rendimiento ya que no se cargan en memoria hasta que no se las llame (a
una de sus unidades de programa).
Query Builder proporciona una forma sencilla de acceder a la información de las bases
de datos de su organización de forma que pueda analizar su estructura. Query Builder
presenta las tablas gráficamente, lo que proporciona una idea intuitiva para la creación
gráfica de una consulta. En Query Builder cada consulta aparece como un rectángulo en
la ventana Consulta (Query). Las columnas de la tabla aparecen en la ventana Consulta
debajo del nombre de la tabla.
La ventana Consulta está dividida en dos secciones, la de Condiciones (Conditions) y la
de Origen de datos (Datasource). En la sección de Origen de datos se especifican las
tablas y las columnas que participan en la consulta. Query Builder entiende que dos
tablas están relacionadas si hay una línea que las une.
Con Query Builder podrá establecer condiciones múltiples, ordenar sus resultados y
generar subtotales. Además podrá realizar cálculos sobre los datos para crear tablas de
hipótesis y estimación (what-if scenarios y forecasts), cambiar tipos de fuente y
formatos, imprimir y guardar los datos recuperados, así como exportarlos a otras
aplicaciones (p.e Excel).
Los resultados de la consulta se presentan en la ventana de resultados (Results).
El Editor de datos (Data Editor) le permite realizar operaciones de actualización de la
base de datos (inserción, actualización y eliminación). Sin embargo, la opción del Editor
de datos suele estar desactivada, y no podrá acceder a ella si no tiene los privilegios
suficientes.
Schema Builder es una herramienta gráfica que le permite crear, copiar, modificar y
eliminar objetos y relaciones de una base de datos. Un esquema es un conjunto de
objetos de una base de datos a nivel lógico, como son tablas, relaciones, vistas e
índices. La interfaz de Schema Builder tiene un aspecto similar al de la ventana de
Consulta en Query Builder, pero en lugar de permitirle realizar consultas sobres las
tablas, Schema Builder le permite realizar operaciones de DDL. Sin embargo, como
Schema Builder le permite modificar la estructura de la base de datos, no podrá acceder
a él si no tiene los privilegios suficientes.

b. El proceso de desarrollo de una aplicación

Este proceso está basado en técnicas de la Ingeniería del Software y cubre aspectos
sobre el análisis, la planificación, el diseño, el desarrollo y la prueba del software. Por
tanto, el seguimiento de este proceso permite generar un software de calidad, fácil de
mantener y minimiza las posibilidades de rechazo de la aplicación.
Antes de comenzar con el desarrollo de una aplicación, hay que determinar lo que el
usuario espera de la aplicación. Este análisis permitirá desarrollar una aplicación basada
en las necesidades del usuario, lo que supone realizar un esfuerzo extra por comprender
a los propios usuarios. Esto supone realizar una análisis del usuario y de las tareas que
realiza el usuario.
Para ello, podemos crear un modelo basado en las tareas que realiza cada usuario,
indicando la secuencia de operaciones de cada tarea junto con los objetos que se utilizan
para el desarrollo de cada una de ellas. Si no comprendemos realmente a los usuarios,
nunca podremos desarrollar la aplicación que ellos necesitan.
Para definir los requerimientos del usuario:
 Recopilaremos información. Técnicas, procedimientos y manuales existentes del
sistema (si ya estaba informatizado) que ayuden a comprender el sistema, de forma
que se puedan realizar las entrevistas con una comprensión previa del sistema actual.
 Observaremos a los usuarios en su trabajo. Hay que confeccionar una lista de las
tareas que realizan los usuarios y determinar el orden en que las realizan
 Entrevista a los usuarios. A la hora de realizar las entrevistas:
- No le pregunte sólo lo que hacen, sino cómo lo hacen (p.e. sabemos que trabajan con
informes, pero, ¿necesitan trabajar con más de un informe a la vez?)
- Encontrar a qué usuarios no les gusta el sistema actual
- Preguntar a los usuarios cómo esperan que sea el modo de operación de la aplicación
- Determinar si los usuarios tienen algún tipo de discapacidad o hay alguna
circunstancia especial que hay que considerar (p.e. idioma, red)
 Entrevista a varios tipos de usuarios y de varios tipos o perfiles
En la siguiente etapa, debemos planificar el desarrollo de la interfaz de forma que se
ajuste a las necesidades del usuario. Esto implica:
 Desarrollar estándares a seguir en el equipo de desarrollo
 Considerar requerimientos y restricciones derivados de la plataforma
 Hacer un diseño previo de la interfaz (prototipo) indicando los tipos de elementos que
se van a utilizar y comprobar que se ajusta a las necesidades del usuario
Una vez recopilada la información suficiente sobre los usuarios y las tareas que realizan
y una vez que haya definido los estándares y los haya utilizado para desarrollar el
modelo de su aplicación, podrá comenzar a desarrollar un prototipo de la interfaz de su
aplicación. Una vez que haya creado un prototipo, en papel o con Developer, muestre a
los usuarios su trabajo y déjeles trabajar con él. Para ello puede:
 Crear algún cuestionario que permita la evaluación
 Elija un conjunto representativo de usuarios
 Capte las impresiones del usuario
 Utilice varias personas para interpretar los resultados del usuario
Tras captar las impresiones del usuario, si es necesario, vuelva a revisar la interfaz de
usuario para que se ajuste a las críticas del usuario
c. Diseño de un formulario con Form Builder
En esta sección veremos cómo crear un formulario sencillo y cómo crear un formulario
maestro-detalle con Form Builder. Pero antes de eso, comentemos algunos conceptos
básicos.
Los formularios creados con Form Builder están compuestos de lo que se denominan
módulos. Concretamente hay cuatro tipos de módulos:
 Módulo Formulario (Form). Colección de objetos como ventanas, cuadros de texto,
casillas de verificación, botones, cuadros de lista y bloques de código PL/SQL
denominados disparadores.
 Módulo Menú. Colección de menús y elementos de menús (órdenes).
 Módulo Librería PL/SQL (PL/SQL Library). Colección de procedimientos, funciones y
paquetes que pueden ser llamados por otros módulos de la aplicación.
 Módulo Librería de objetos (Object Library). Colección de objetos que se pueden
utilizar para el desarrollo de una aplicación.
1. Formularios, bloques, elementos, regiones y marcos

Un formulario (o módulo formulario) es una aplicación que proporciona acceso a una fuente de
datos. Al ver un formulario, se observan elementos de la interfaz como cuadros de texto y
casillas de verificación, lo que permite interactuar con la fuente de datos. Estos elementos de la
interfaz pertenecen a lo que se denomina un bloque.
En la figura siguiente, los campos Número, Ciudad y Nombre pertenecen al bloque
Departamento, mientras que los campos Número, Nombre, Empleo, Jefe, Fecha entrada, Sueldo
y Complemento pertenecen al bloque Empleados.
Figura Un formulario

Hay dos tipos de bloques: bloques de datos, que se utilizan como puente entre el usuario y la
fuente de datos, y bloques de control, que no están asociados a ninguna fuente de datos. Cada
bloque de datos permite a un usuario acceder a los datos de una tabla, consulta o vista de la
fuente de datos. Además, los bloques pueden tener un solo registro (como el bloque
Departamento de la figura anterior), lo que significa que sólo se puede acceder a una fila en un
instante, o pueden tener varios registros (como el bloque Empleados de la figura anterior), lo que
significa que se pueden ver varios registros a la vez.
Una región es un rectángulo que agrupa de forma lógica ciertos campos dentro de un bloque,
mientras que un marco es una forma de organización predefinida de elementos en un bloque.
Concretamente el marco configura aspectos como los márgenes y distancias entre elementos.
2. Ventanas y canvas
Una ventana es el contenedor en el que se muestran todos los objetos visuales de un formulario.
Un formulario puede constar de varias ventanas, pero lo más común es tener un formulario para
cada ventana.
En Form Builder tenemos los siguientes tipos de ventanas:
- Contenedor (MDI). Contiene al resto de las ventanas. Suele contener a la barra de
herramientas y al menú principal.
- No modales. Permiten al usuario interactuar con cualquier otra ventana, así como con la barra
de herramientas y el menú.
- Modales. Obligan al usuario a trabajar con una única ventana, de forma que sólo pueda
aceptar o cancelar los cambios que realice. La barra de herramientas y el menú no son
accesibles. Se suelen utilizar en los cuadros de diálogo de configuración de propiedades y en
los asistentes.
Un canvas (lienzo o superficie) es el objeto implícito sobre el que aparecen los elementos de la
interfaz. Un formulario puede tener varios canvas, como si se tratasen de las páginas de un
formulario. Un canvas puede mostrar elementos de uno o más bloques. Para poder ver los
elementos de un canvas, tiene que colocar el canvas en una ventana.
Existen cuatro tipos de lienzos:
- Canvas de contenido. Ocupan toda la ventana. Cada ventana tiene al menos un lienzo de
contenido.
- Canvas apilados. Aparecen apilados sobre el lienzo de contenido. Se utilizan para ocultar
zonas de un lienzo de contenido.
- Canvas con fichas. Un conjunto de fichas que le permiten agrupar y presentar una gran
cantidad de información relacionada en el espacio de un solo lienzo.
- Canvas de barras de herramientas. Se utilizan para crear barras de herramientas. Cada
ventana puede presentar un canvas o más, y además se pueden presentar de forma
condicional, dependiendo de si se cumplen ciertas condiciones.
3. Creación de un formulario
Puede crear un formulario de varias formas.
 Ejecutando Form Builder. Esto le lleva al cuadro de diálogo de bienvenida de Form Builder que
se muestra en la figura siguiente. En este cuadro de diálogo podrá:
- Utilizar el Asistente para bloques de datos, que le asiste en el proceso de creación de un
bloque de datos.
- Crear un formulario de forma manual, que muestra directamente el Explorador de objetos
para cree un formulario a partir de uno vacío.
- Crear un formulario a partir de una plantilla.

Figura Cuadro de diálogo de bienvenida de Form Builder.

 Si ya está ejecutando Form Builder, puede crear un nuevo formulario de alguna de estas
formas:
- Seleccionar File|New|Form del menú
- Situar el ratón sobre Forms en el Explorador de objetos, y pulsar sobre el botón Create.
Bueno, comencemos a crear nuestro formulario, y comencemos aprendiendo a cambiar su

nombre. Para cambiar el nombre de un formulario, basta con pulsar una vez sobre el nombre del
formulario en el Explorador de objetos, una vez que esté seleccionado. El método es el mismo
que el que se sigue para cambiar el nombre de un archivo en Windows 9x. Una vez que hemos
aprendido a cambiar el nombre de un formulario, veamos cómo podríamos acceder al Cuadro de
Propiedades. Para cada objeto que veamos en Form Builder, y en general en el resto de las
herramientas de desarrollo de D2K, podemos manipular sus propiedades a través del Cuadro de
Propiedades, que aparece en la ilustración siguiente.
Figura. Cuadro de Propiedades.

Para activar el Cuadro de Propiedades, basta con pulsar dos veces en el Explorador de objetos
sobre el objeto cuyas propiedades queremos configurar o consultar. Esta acción abrirá el Cuadro
de Propiedades y mostrará las propiedades del objeto activo junto con sus valores, de forma que
si en el Explorador de objetos seleccionamos otro objeto, el Cuadro de Propiedades mostrará las
propiedades del nuevo objeto seleccionado.
Veamos ahora cómo crear un bloque de datos nuevo.
Un formulario consta de uno o más bloques de datos y bloques de control. Ahora que ya sabemos
crear módulos de formulario, vamos a ver cómo podemos crear los bloques de datos del
formulario.
NOTA: La creación de un bloque de datos supone la creación del propio bloque de datos y la
creación de su diseño para su presentación en el formulario. Puede crear los bloques de datos de
forma manual o utilizando los asistentes de Form Builder.
Veamos cómo crear un bloque de datos y su presentación para la tabla de departamentos
utilizando el Asistente para bloques de datos (Data Block Wizard) y el Asistente de presentación
(Layout Wizard).
Lo primero que tenemos que hacer, a no ser que ya lo hayamos hecho, es conectarnos a la base
de datos. Para ello, introduciremos nuestro nombre de usuario, contraseña y nombre de la base
de datos.
A continuación iniciaremos el Asistente para bloques de datos seleccionado Tools|Data Block
Wizard. Una vez pasada la pantalla de bienvenida, hay que indicar al asistente si nuestro bloque
de datos está basado en una tabla o vista, o bien está basado en un procedimiento, tal y como
muestra la figura siguiente.
Figura Selección del origen de datos del bloque de datos.

Para nuestro ejemplo, seleccionaremos Table or View, ya que vamos a crear un bloque de datos
para la tabla de departamentos.
A continuación, aparecerá un nuevo paso del asistente en el que indicaremos cuál es la tabla o
vista sobre la que vamos a construir el bloque de datos, y cuáles son las columnas que vamos a
incluir en nuestro bloque de datos.

Para ello, pulsaremos el botón Browse para examinar las tablas de nuestra base de datos y elegir
la tabla de departamentos. A continuación aparecerán en el cuadro de Available Columns las
columnas de nuestra tabla, y podremos seleccionar cuáles son las columnas que queremos que
formen nuestro bloque de datos. En este ejemplo pasaremos todas al cuadro de Database Items,
tal y como muestra la figura siguiente.
Figura. Selección de los elementos del bloque de datos.

Una vez seleccionados los campos del bloque de datos, pasamos al paso siguiente en el que
podemos elegir entre lanzar el Asistente de presentación de nuestro bloque de datos, o detener
el proceso. En nuestro caso elegiremos seguir con el Asistente de presentación, tal y como
muestra la figura siguiente.
Figura Finalización de la creación del bloque de datos y llamada al Asistente de presentación.

A continuación vamos a crear una presentación para nuestro bloque de datos, y comenzaremos
seleccionando el tipo de canvas que vamos a crear. El tipo puede ser Content, para ser uno
principal o continente, Stacked, Vertical Toolbar u Horizontal Toolbar para la creación de barras
de herramientas, o bien del tipo Tab si lo que queremos es crear un canvas con fichas. En
nuestro caso elegiremos el tipo Content, tal y como muestra la figura y a continuación pasaremos
al paso siguiente.
Figura . Elección del tipo de canvas.

En este paso tendremos que seleccionar los elementos del bloque de datos que queremos incluir
en el canvas, o lo que es lo mismo, los campos que queremos mostrar.
Para ello, basta con seleccionar los elementos del cuadro Available Items y pasarlos al cuadro
Displayed Items, tal y como muestra la figura siguiente
Figura. Selección de los elementos mostrados en el canvas.

A continuación, pulse el botón Finish, y obtendrá un resultado como el siguiente.
Figura. Resultado de crear un bloque de datos y definirle una presentación.

En esta ventana podemos modificar el diseño de nuestro formulario, y desde el menú podemos
guardarlo con File|Save y ejecutarlo con Program|Run Form. Antes de ejecutarlo cambiemos las
etiquetas de los campos de forma que sean más descriptivas.
Esto lo podemos hacer modificándolas directamente o bien a través de la propiedad Prompt del
Cuadro de Propiedades. Cambie las etiquetas a Número y Departamento.
Si ahora ejecuta el formulario verá que el aspecto se ajusta a lo que aparecía en la ventana de
diseño, pero hay algunas cosas que habría que modificar, tal y como el nombre de la ventana, y
cómo hacer que aparezcan los registros.
Para modificar el nombre de la ventana, tiene que cambiar la propiedad Name del objeto Ventana
en el que esté definido el canvas (p.e. cambiar WINDOW1 por DEPARTAMENTOS). En cuanto a la
razón por la que no aparecen los registros, lo vamos a ver a continuación.
Cuando esté ejecutando un formulario con el runtime, verá que sus registros no aparecen
automáticamente al presentarse el formulario. Esto se debe a que el runtime de Form Builder
está esperando a que introduzca un nuevo registro o a que introduzca una consulta para mostrar
la información solicitada.
Lo que hay que hacer para ver todos los registros de un formulario es introducir una consulta y
ejecutarla. Para ejecutar una consulta sencilla bastará con introducir los parámetros en los
cuadro de edición correspondientes y lanzar la consulta pulsando el botón Execute Query de la
barra de herramientas. En esta barra de herramientas también nos encontramos los botones de
Enter Query para especificar una nueva consulta, y el botón Cancel Query que cancela la
introducción de una consulta. La figura siguiente muestra estos tres botones
Figura. Botones de consultas.

Para mostrar en el formulario todos los registros, pulsaremos el botón de ejecutar consulta, y se
ejecutará sin ninguna condición, por lo que se mostrarán todos los registros, tal y como se
muestra en la figura siguiente.

Figura. Presentación de todos los registros.

Ahora puede utilizar los botones de navegación por los registros para desplazarse por los
resultados.
Para introducir consultas que muestren información concreta, habilitaremos el modo de
introducción de consultas del runtime pulsando el botón de introducir consulta, y escribiremos en
el formulario los valores que queremos que cumplan los registros resultantes, teniendo en cuenta
que, en principio, la consulta se hace con comparación exacta de cadenas (sensible a las
mayúsculas) y equivale a un AND lógico. Por tanto, para conocer cuáles son los departamentos
de Dallas, habilitaremos el modo de introducción de consultas en el formulario, escribiremos
DALLAS en el campo Ciudad, y pulsaremos el botón Execute Query. Este proceso se muestra en
la figura siguiente.
Activación del modo de introducción de consultas
Introducción de parámetros
Presentación de resultados

Figura. Información de departamentos de Dallas.

Si desea especificar varias condiciones para que se cumplan simultáneamente en varios campos,
tendrá que introducir los valores deseados en cada uno de los campos correspondientes. Este tipo
de consulta que hemos visto, sólo permite especificar condiciones AND y con un solo valor de
comparación por campo.
A continuación vamos a ver cómo podemos especificar condiciones OR y varias condiciones por
campo.El proceso consta de dos partes:
 Definición de ‘variables’ en los campos sobre los que queremos definir las condiciones
escribiendo en cada campo (:nombreVariable)
 Especificación de los predicados del WHERE en el Editor de predicados WHERE
(Query/Where), utilizando los nombres de variable anteriores.
Por ejemplo, para obtener la información sobre los departamentos de los estados de Dallas y
Nueva York, introduciremos en el campo Ciudad :C. Esto define una variable (para eso se
incluyen los dos puntos) denominada C, que es la que vamos a utilizar en el Editor de predicados
WHERE. Por tanto, el resultado de nuestro primer paso sería algo así.
Figura. Definición de una variable para especificar una condición múltiple sobre Ciudad.
Si ahora pulsa el botón Execute Query aparecerá el cuadro de diálogo Query/Where, en el que
debe especificar su predicado WHERE en SQL, utilizando la variable junto los dos puntos que ha
definido en el formulario, tal y como se muestra en la figura siguiente. Además, en este editor
podrá hacer búsquedas y sustituciones de cadenas.
Figura. Definición de predicados múltiples.

Una vez que finalice la introducción de la consulta, pulse OK y aparecerán en su formulario los
registros que cumplen la condición que ha especificado.
Para editar la consulta basta con volver a introducir una consulta (puede ser la misma) que utilice
variables de este tipo, y el cuadro de diálogo que aparece es el mismo. La figura siguiente
muestra una modificación realizada a la consulta para que presente los resultados ordenados por
Estado. En cuando a las ordenaciones, las puede realizar directamente sobre el nombre de la
columna, sin necesidad de utilizar un nombre de variable, tal y como se muestra en la figura
siguiente.
Figura. Especificación de un predicado WHERE junto con una cláusula de ordenación.

Un formulario no vale exclusivamente para la visualización de datos y ejecución de consultas,
sino que también se utilizan para la modificación de la base de datos. Por tanto, las operaciones
de inserción, modificación y eliminación de SQL se pueden hacer de una forma más intuitiva a
través de la interfaz de un formulario.
Antes de pasar a ver cómo se realizan estas tres operaciones, decir que los cambios que se
realicen tienen carácter temporal, y que sólo se hacen persistentes (se guardan realmente en la
base de datos) cuando se pulse el botón Save de la barra de herramientas, o bien seleccione
Action|Save. Si lo que desea es cancelar los cambios, seleccione Action|Clear All.
Para insertar un registro, basta con situarse sobre un registro en blanco (el siguiente al último), o
bien pulsar el botón Insert Record de la barra de herramientas, o bien seleccionar Record|Insert.
A continuación, inserte los valores que desee en los campos correspondientes.
Para eliminar un registro, primero deberá situarse sobre el registro que desea eliminar (p.e.
realizando una consulta) y luego pulse el botón Remove Record, o bien seleccione
Record|Remove.
Para actualizar un registro, sólo tendrá que situarse sobre el registro que desee modificar (p.e.
haciendo una consulta) y realizar las modificaciones necesarias.
4. Creación de formularios Maestro-Detalle

A menudo es necesario la presentación o la introducción de detalles para un grupo de registros
iterando sobre un mismo registro, como puede ser el caso de presentar en un formulario todos
los departamentos, y en el que para cada departamento podamos iterar sobre cada uno de sus
empleados.
Esta idea facilita la interacción con la base de datos y a estos formularios se les denomina
Maestro-Detalle, ya que el formulario está basado en un formulario Maestro, en el que podemos
ver cada uno de sus registros de detalle.

Para la interconexión de la parte maestro y de la parte detalle se utilizan las claves externas, es
decir se presentan todos los registros de la parte detalle en los que los valores de la clave
externa en la tabla que actúa como detalle coincida con los valores de la clave en la tabla que
actúa como maestro. Esta idea de formularios no tiene una configuración única, ya que el
formulario detalle, puede ser a su vez maestro de otro formulario, o un formulariomaestro puede
ser maestro de formularios detalle, tal y como se ilustra en la figura siguiente.
Figura. Relaciones Maestro-Detalle.

Una vez introducida la idea de formularios Maestro-Detalle, veamos cómo podemos realizar esto
con Form Builder.
Para ello necesitaremos haber definido el bloque maestro, que en nuestro caso nos basta con la
definición del bloque de datos DEPT que definimos anteriormente. A continuación crearemos un
nuevo bloque de datos para la parte detalle utilizando el Asistente para Bloques de datos.
En el cuadro de diálogo en el que hay que seleccionar el origen de los datos, seleccionaremos la
tabla EMP, y en el cuadro Database Items incluiremos todos los campos de la tabla. A
continuación, en el cuadro de diálogo siguiente marcaremos la casilla de verificación Auto-join
data blocks, para que una vez seleccionado el bloque maestro, realice la conexión de la parte
detalle con la parte maestro a través de la clave externa. Ahora pulsaremos el botón Create
Relationship y en el cuadro de diálogo que aparece, seleccionaremos la tabla DEPT (a la que hace
referencia la clave externa de EMP), y veremos que el cuadro de Join condition se rellena
automáticamente con la condición de producto natural, quedando como la figura siguiente.
Figura . Creación de una relación Maestro-Detalle.

Una vez finalizada la creación del bloque de datos, falta crear el diseño de su presentación, y a
continuación detallamos los pasos que vamos a seguir.
El primer paso importante es elegir si queremos presentar nuestro detalle junto a la parte
maestro (en el mismo canvas), o lo queremos presentar en un cuadro aparte (en otro canvas
nuevo). Nosotros elegiremos el mismo canvas que es la forma más común.
En el paso siguiente, nos aseguraremos que el bloque de datos seleccionado es el de EMP, y a
continuación pasaremos al cuadro de Displayed Items todos los campos excepto NUMDEP, puesto
que ya aparece en la parte maestro, de forma que nuestro cuadro de diálogo quedaría así.
Figura. Definición de los campos a presentar en la parte detalle.

El paso siguiente se utiliza para modificar el tamaño de los cuadros de texto, que dejaremos con
los valores por omisión, y en el cuadro de diálogo siguiente podemos elegir si la parte detalle se
presenta en formato de formulario (ficha por cada detalle), o bien en formato tabular. Nosotros
elegiremos el formato tabular que es el más común para formularios Maestro-Detalle, ya que
permite ver varios registros de detalle por cada registro del maestro.
A continuación, el asistente muestra un cuadro de diálogo para que introduzcamos el nombre que
deseamos que aparezca en la parte detalle, el número de registros que queremos ver
simultáneamente en la parte detalle, y si deseamos presentar una barra de desplazamiento para
poder ver registros que no quepan en el área definida.
En nuestro caso, elegiremos como título Empleados, como número de registros presentados 5, y
además presentaremos la barra de desplazamiento.
Una vez que haya finalizado el diseño del formulario Maestro-Detalle, podrá modificar su diseño,
y el resultado final deberá ser similar al que se muestra en la figura siguiente.

Figura. Formulario Maestro-Detalle.

Al crear una relación Maestro-Detalle entre dos bloques de datos, se crea un objeto Relation en el
bloque de datos que actúa como maestro. Las propiedades más importantes de este objeto son:
 Detail Data Block: Indica cuál es el bloque de datos que actuará como detalle.
 Join Condition: Indica la condición de producto natural entre los bloques de datos.
 Delete Record Behavior: Especifica cómo afecta al detalle la eliminación de un registro del
bloque de datos maestro.
- Non-Isolated: Previene la eliminación de un registro maestro si hay registros detalle.
- Isolated: Permite la eliminación de registros del bloque maestro sin afectar a los registro del
detalle.
- Cascading: Realiza una eliminación en cascada de los registros del bloque de datos del
detalle al eliminar un registro del bloque de datos maestro. En una relación maestro-detalle
de varios niveles, las eliminaciones no se propagan de forma automática.
 Prevent Masterless Operations: Previene la inserción de registros en el detalle si no hay
registros relacionados en el maestro. Además, impide que se realicen consultas sobre el
detalle sin especificar condiciones en el maestro, debido a las relaciones M:N.
Para crear nuevas relaciones maestro-detalle, basta con repetir la creación del bloque detalle
desde el principio, teniendo en cuenta que el bloque maestro siempre tendrá que estar creado
previamente.
5. Control de las propiedades de los bloques de datos
Hasta ahora, nos hemos limitado a crear bloques de datos indicando cuál era el origen del bloque
de datos, y las columnas que queríamos incluir, pero no hemos hablado nada del resto de las
propiedades.
Pese a que los bloques de datos tienen muchísimas propiedades, no es nuestro objetivo conocer
cada una de ellas, pero sí conocer el uso de las más frecuentes e importantes. Es por ello que
vamos a dedicarle a continuación un pequeño espacio a dichas propiedades.
 Propiedades sobre el estilo de navegación
- Navigation Style: Indica a dónde se dirige el enfoque cuando se abandona el primer o el
último campo de un registro. Puede seguir en el mismo registro (Same Record), cambiar de
registro (Change Record), o cambiar de bloque de datos (Change Data Block).

- Previous/Next Navigation Data Block: En el caso de que en la propiedad Navigation Style

elija Change Data Block, con estas propiedades puede indicar cuáles serán los bloques que
recibirán el enfoque al cambiar.
 Propiedades sobre la base de datos
- Database Data Block: Indica si el bloque es un bloque de datos o es un bloque de control.
- Enforce Primary Key: Indica a Form Builder que se encargue en la medida de lo posible de
comprobar que los registros que se están introduciendo no tengan el mismo valor en su
clave primaria. Esto evita enviar a la base de datos registros erróneos, lo que reduce el
tráfico de la red.
- Query/Insert/Update/Delete Allowed: Permite o impide que se realicen consultas,
inserciones, actualizaciones o eliminaciones en el bloque de datos.
- WHERE Clause: Especifica una cláusula WHERE por omisión. Cualquier condición que
imponga el usuario se añadirá con un AND a esta cláusula WHERE por omisión.
- ORDER BY: Especifica una clave de ordenación por omisión.
- Update Changed Columns Only: Modifica solamente las comunas que se han modificado, lo
que reduce el tráfico de la red.
- Maximun Query Time: Limita el tiempo máximo que se le puede conceder a la ejecución de
una consulta. Si se alcanza este límite se aborta su ejecución.
- Maximun Records Fetched: Limita el número máximo de registros que puede devolver una
consulta.
 Propiedades sobre los registros
- Query Array Size: Especifica el número máximo de registros que entrega la base de datos a
Form Builder cada vez. Un valor pequeño implica un menor tiempo de comunicación,
mientras que un número grande reduce el número de operaciones de comunicación, por lo
habrá una solución de compromiso.
- Query All Records: Indica si la base de datos debe enviar a Form Builder todos los registros
cuando se ejecute una consulta.
6. Creación de elementos de texto
Aunque en principio todos los campos que aparecen en los formularios son elementos de texto,
nosotros vamos a utilizar los elementos de texto para mostrar campos calculados.
Para ello tendremos que crear un elemento de texto en la representación de un bloque de datos
(ya que el cálculo hará referencia a una combinación de sus campos). A continuación, en la
propiedad Calculation Mode, elegiremos Formula, y en la propiedad Formula, introduciremos la
fórmula.
Las fórmulas se introducen utilizando como operandos con esta sintaxis:
:nombreTabla.nombreColumna
Por tanto, si queremos calcular el sueldo total de los empleados de cada departamento,
escribiremos en el campo Formula del elemento de texto :emp.sueldo + :emp.complemento. Si
además añadimos alguna característica de formato, podemos obtener un resultado como el de la
figura siguiente.

Figura. Utilización de elementos de texto para la realización de cálculos.
7. Presentación de indicaciones y uso de casillas de verificación

En las interfaces que necesitan la introducción de algún tipo de datos por parte del usuario, es
necesario informar al usuario del tipo de acción que tiene realizar, ya que no basta con las
etiquetas que aparecen junto a los cuadros de introducción de datos.
Para ello se utilizan mensajes explicativos en la barra de estado para que aparezcan de forma
automática cuando el elemento reciba el enfoque. Esto se consigue con las propiedades Hint y
Display Hint Automatically. La propiedad Hint se configura con el mensaje que queramos mostrar
en la barra de estado.
Por ejemplo, para indicar al usuario que el número de empleado ha de ser un número de cuatro
dígitos, crearemos esta indicación “Introduzca un número de cuatro dígitos”, de forma que
cuando el número de empleado reciba el enfoque, aparezca dicho mensaje en la barra de estado,
tal y como muestra esta figura.
Figura. Formulario con indicaciones para el número de empleado.

Si lo que desea es que aparezca una sugerencia cuando el puntero del ratón se sitúe sobre un
elemento de la interfaz, debe configurar la propiedad Tooltip con el texto que desea que aparezca
(p.e. Un número de cuatro dígitos que identifica al empleado en la empresa).
Figura. Ejemplo de utilización de las sugerencias para el número de empleado.

Ahora vamos a ver cómo crear casillas de verificación. Para ello, necesitamos que hagan
referencia a una columna de una tabla, por lo que tendremos que añadir alguna columna a
alguna de las tablas con las que estamos trabajando.
Concretamente vamos a añadir dos columnas nuevas a la tabla de departamentos. Se trata de
dos columnas que indican si el departamento tiene cobertura nacional y cobertura internacional.
Por tanto, desde SQL*Plus modificaremos la estructura de la tabla para añadir estas dos
columnas, y lo haremos con la instrucción
ALTER TABLE de la forma siguiente.
ALTER TABLE EMP (ADD NACIONAL CHAR, ADD INTERNACIONAL CHAR);
Una vez que hemos creado estas dos nuevas columnas, necesitamos incorporarlas al bloque de
datos de departamentos, y a continuación añadir dos nuevos campos a la presentación del bloque
de datos. A continuación se muestra como podemos realizar estos dos pasos.
Para añadir un nuevo elemento al bloque de datos de departamentos, seleccionaremos el bloque
de datos de departamentos en el Explorador de objetos, y a continuación seleccionaremos
Tools|Data Block Wizard, para activar el asistente de bloques de datos y poder modificar el
bloque de datos de departamentos.
En el cuadro de diálogo que aparece, seleccionaremos la ficha Table, y pulsaremos el botón
Refresh para que muestre las columnas que acabamos de añadir a la tabla. Una vez que
aparezcan estas columnas, las llevaremos al cuadro Database Items, tal y como muestra la figura
siguiente. Una vez hecho esto pulse el botón Finish.

Figura. Modificación de un bloque de datos.

Ahora, una vez que se ha modificado el bloque de datos, tenemos que modificar el diseño de la
presentación, de forma que podamos acceder a los nuevos elementos del bloque de datos. Para
ello, seleccione el marco de departamentos en la vista de diseño del formulario y seleccione
Tools|Layout Wizard.
Una vez que aparezca el asistente, tiene que incluir en el cuadro Displayed Items de la ficha Data
Block, los dos elementos nuevos del bloque de datos. Una vez que haya añadido los dos
elementos, deberá especificar para cada uno que se trata de una casilla de verificación, y no de
un cuadro de edición de texto (valor por omisión).
Para ello, seleccione Check box en la lista desplegable Item Type, de forma que su cuadro de
diálogo sea similar al de la figura siguiente.
Figura. Modificación del diseño de un bloque de datos.

Una vez seleccionados los dos nuevos elementos de bloque de datos, y una vez que se han
configurado como casillas de verificación, acepte los cambios. Por último, lo único que falta por
hacer es asignarle a cada uno de ellos un valor para cuando la casilla esté marcada y otro valor
para cuando la casilla no esté marcada.
Esto se realiza escribiendo un valor en las propiedades Value When Checked y Value When
Unchecked, que si bien pueden tomar cualquier valor permitido por el tipo de datos del elemento,
se suelen utilizar los valores V y F, o T y F, ya que se trata de variables lógicas. Observe cómo se
ha realizado esto para la columna internacional en la figura siguiente.
Figura. Asignación de valores a los dos estados de una casilla de verificación.
8. Utilización de listas de valores y cuadros de lista

A menudo es necesario utilizar campos en los formularios en los que la entrada de datos esté
limitada a una serie de valores. Con esto se consigue que el usuario no tenga que recordar
exactamente los valores permitidos, sino que le basta con seleccionar uno entre una lista.
Además evita que se cometan errores de escritura, ya que el valor es seleccionado de una lista.
Form Builder ofrece dos mecanismos para la creación de listas de valores. El primero que
veremos son las LOVs (Listas de valores, List Of Values), y luego veremos los conocidos cuadros
de lista o cuadros combinados. Las LOVs son listas que aparecen en una ventana aparte, donde
el usuario selecciona un valor, y este valor seleccionado es el que se pasa al campo al que está
ligado la LOV. Las LOVs están basadas en grupos de registros (Record groups) obtenidos a partir
de consultas SQL. Para crear una LOV, hay que añadir un nuevo objeto en la categoría LOVs del
Explorador de objetos. A continuación, en la ventana que aparece indicaremos el origen de los
valores que mostrará la LOV. Esto se realiza especificando un grupo de registros definido
previamente o bien creando uno nuevo escribiendo una consulta en el cuadro
Query Text. Nosotros vamos a crear una LOV para mostrar los nombres de los departamentos, y
así no tener que conocer cuáles son los nombres disponibles, y además evitar errores. Por tanto,
tenemos que seleccionar los nombres de los departamentos de la tabla de departamentos. A
continuación se muestra cómo quedaría la definición de la LOV.

Figura. Definición de una LOV.

Esta operación ha creado una lista de valores y un grupo de registros. Observe que los nombres
que ha generado Form Builder han sido LOVxx. Vamos a cambiar estos nombres a algo más
significativo, como es DEPARTAMENTOS.
Para cambiar el nombre del grupo de registros puede hacerlo pulsando dos veces sobre el
nombre del grupo de registros, o bien, mostrando sus propiedades y modificando la propiedad
Name. Si lo hace de esta forma, verá que en Record Group Query se encuentra definida la
consulta que seleccionar los valores de la lista. Podrá observar también que el número de valores
está limitado por la propiedad Record Group Fetch Size.
A continuación, cambiaremos el nombre de la LOV, y también lo podemos hacer de las dos
formas, aunque lo haremos desde el Cuadro de Propiedades, ya que tenemos que modificar más
propiedades aparte del nombre.
Concretamente, cambiaremos el nombre por DEPARTAMENTOS, y observaremos que ha
cambiado el nombre del grupo de registros al que estaba ligado por el de DEPARTAMENTOS. A
continuación, veremos algunas de las propiedades más importantes de la categoría Functional.
 Column Mapping Properties: Permite definir un campo del formulario para que tome el valor
seleccionado en la LOV. Concretamente tiene que escribir el nombre del campo en Return
Item. Para nuestro ejemplo escribiremos NOMBREDEP.
 Automatic Display: Indica si se activa automáticamente la LOV al seleccionar el campo al que
está ligada.
 Automatic Refresh: Indica si se realiza una actualización automática de la lista al insertar
nuevos valores.
 Automatic Position: Indica si la lista aparece cerca del campo.
Además, la propiedad Title define el título de la ventana de la LOV, de forma que quede descrita
por un texto sugerente, como puede ser Departamentos disponibles.
Una vez configuradas las propiedades de la lista, sólo falta configurar el campo del formulario
para que esté ligado a la lista. Esto se hace configurando la propiedad List of Values del campo
correspondiente, en este caso NOMBREDEP, tal y como muestra la figura siguiente.

Figura. Configuración de una LOV para que devuelva el valor seleccionado

Así pues, ahora cada vez que seleccione el campo del nombre del departamento se abrirá la LOV
para que seleccione un valor. Al pulsar OK el valor seleccionado pasará al campo del nombre del
departamento. Si quiere añadir un valor nuevo, cancele la selección de valores de la lista, y edite
directamente el valor del campo. Una vez que guarde el registro modificado este valor formará
parte de la lista, gracias a la propiedad Automatic Refresh.
Figura. Utilización de una LOV.

Una vez vistas las LOVS (listas de valores basadas en consultas SQL), pasemos a ver los cuadros
de lista. A diferencia de las LOVs, los cuadros de lista contienen una lista de valores definidos
previamente, pero no están basadas en consultas SQL.

Por tanto, no son tan flexibles, pero son útiles cuando se conocen previamente los valores del
dominio del campo sobre el que se van a definir.
Form Builder permite la utilización de tres tipos de cuadros de lista:
 Listas emergentes (Pop-Up Lists): Se trata de un campo con una flecha a la derecha para
mostrar la lista de valores. Este tipo de listas no permite la introducción de valores desde
teclado.
 Cuadros combinados (Combo Boxes): Son listas emergentes que permiten la introducción de
datos por parte del usuario.
 Listas rectangulares (TLists): Se trata de cuadros que tienen una lista de valores que pueden
ser recorridos mediante una barra de desplazamiento.
La figura siguiente muestra distintas presentaciones del nombre del departamento para que
observe la diferencia entre las listas emergentes y las listas rectangulares.
Figura. Cuadros de lista.

Para definir un cuadro de lista, sólo hay que especificar en la propiedad Item Type del elemento
correspondiente del bloque de datos que se trata de un cuadro de lista (List Item). A
continuación, en la propiedad List Style se debe especificar el tipo de cuadro de lista.
Una vez especificado el tipo de cuadro de lista, hay que definir los valores de la misma, y esto se
hace configurando la propiedad Elements in List. Al seleccionar esta propiedad aparece un cuadro
de diálogo en el que introduciremos en el cuadro List Elements los valores que queremos que
aparezcan en el cuadro de lista, mientras que en el cuadro List Item Value introduciremos el valor
real con el que se corresponde dicho elemento del cuadro de lista, que no tiene por que ser el
mismo
9. Utilización de botones de opción y botones de orden

A veces se suelen utilizar botones de opción para limitar la selección de valores. Los botones de
opción permiten la selección de un único valor entre una serie de valores, por lo que son
similares a los cuadros de lista. La diferencia está en que los botones de opción se suelen utilizar
cuando la lista de valores es reducida.
Para ello, vamos a añadir una nueva columna a la tabla de departamentos para indicar si un
departamento está inscrito o no en cierto registro escribiríamos desde SQL*Plus lo siguiente:
ALTER TABLE DEPT ADD (INSCRITO CHAR)
que luego podríamos eliminar con
ALTER TABLE DEPT DROP (INSCRITO)
A continuación utilizaríamos el Asistente para bloques de datos para añadir este nuevo campo al
bloque de datos, pero indicaremos que su tipo es Radio Group.

Una vez creado el grupo de botones hay que crear cada uno de los botones, que en este caso
serán dos, uno para inscrito y otro para no inscrito.
Una vez creados los dos botones de opción, hay que configurar algunas propiedades.
Concretamente configuraremos:
 Name: INSCRITO
 Label: Sí/No
 Radio Button Value: T/F
Observe la diferencia entre la propiedad de la etiqueta, que indica lo que se muestra en la
interfaz, y la propiedad del valor, que contiene lo que realmente se guarda en la base de datos.
A continuación puede crear un rectángulo para crear un grupo lógico con los dos botones de
opción, y cambiar las propiedades del fondo (none) y las del título (label), de forma que su
formulario sea similar al de la figura siguiente.
Figura. Formulario con botones de opción.

La creación de botones de orden es algo muy sencillo, pero el problema es que la creación de un
botón de orden supone la asignación de acciones al evento que se produce cuando se pulsa el
botón, y esto se hace mediante instrucciones PL/SQL que no hemos estudiado. No obstante
veremos algo muy sencillo para ilustrar cómo crear dos botones de orden, uno para aceptar los
cambios y otro para salir del formulario.
En primer lugar crearemos los botones seleccionando la herramienta Button de la barra de
herramientas del diseño del formulario y crearemos dos botones. A continuación modificaremos
su nombre y la etiqueta que muestran a través de las propiedades Name y Label. Concretamente
le asignaremos los valores ACEPTAR y SALIR.
Ahora, sobre cada botón pulsaremos con el botón derecho, y en el menú contextual
seleccionaremos la opción Smart Triggers, que lo que hace es mostrar los procedimientos de
evento asociados al objeto seleccionado. Nosotros seleccionaremos WHEN-BUTTON-PRESSED,
que definirá un procedimiento de evento asociado a la pulsación del botón.
Una vez que seleccionemos esta opción, aparecerá un editor de PL/SQL en el que introduciremos
las órdenes PL/SQL que queremos que se ejecuten al pulsar los botones. Concretamente
escribiremos COMMIT; para el procedimiento del botón ACEPTAR y EXIT_FORM para el botón
SALIR. De esta forma habrá creado dos botones de opción elementales en una interfaz de los que
podrá probar su funcionamiento.

10. Creación de una barra de herramientas

Una barra de herramientas no es más que un tipo de canvas especial, por lo que su creación se
limita a crear un canvas, a definir los botones que la forman y a asignar acciones a los botones
(mediante bloques PL/SQL). En esta sección crearemos a modo de ejemplo una barra de
herramientas con dos botones a los que faltaría asociarles el código PL/SQL apropiado.
Para crear una barra de herramientas basta con añadir un nuevo canvas. Para ello, seleccione la
categoría Canvases en el Explorador de objetos y pulse el botón de Crear objeto. A continuación,
active el Cuadro de Propiedades del nuevo canvas, modifique su nombre y en la propiedad
Canvas Type seleccione Horizontal Toolbar para indicar que se trata de una barra de
herramientas horizontal. Por último, asegúrese de que la propiedad Window contiene la ventana
en la que desea que aparezca la barra de herramientas. Si lo desea puede cambiar la
presentación de la barra con la propiedad Bevel.
Una vez definido el canvas de la barra de herramientas, hay que añadirle los botones tal y como
se hizo para añadir los botones de ACEPTAR y SALIR al canvas anterior (de hecho la barra es un
canvas a todos los efectos). Añada dos botones asignándoles un nombre y una etiqueta
apropiada y reduzca el tamaño del canvas para que se ajuste a los botones que haya añadido.
NOTA: Para añadir los botones, tenga seleccionado alguna categoría interior al canvas de la barra
de herramientas en el Explorador de objetos.
Además, sería conveniente que asignara una sugerencia (propiedad Tooltip) a cada botón de
modo que apareciese al situar el ratón sobre el ratón indicando de forma escueta la acción
asociada a dicho botón. Si ahora ejecuta su formulario, el resultado debe ser similar al de la
figura siguiente.
Figura. Creación de una barra de herramientas.
11. Formularios basados en fichas

Los formularios basados en fichas son una solución ideal para crear formularios con gran cantidad
de datos en un espacio mínimo. Para ello se crean un conjunto de fichas superpuestas que
pueden ser seleccionadas pulsando una pestaña. En este tipo de formularios, cada ficha contiene
información relacionada, por lo que en el formulario la información queda dividida en grupos
lógicos correspondientes a cada una de las fichas.
Antes de continuar es conveniente que cree otro módulo nuevo para el formulario basado en
fichas que vamos a crear en esta sección, de forma que pueda comparar la funcionalidad de uno
respecto al otro. Siguiendo con nuestro ejemplo vamos a crear un formulario basado en fichas
para departamentos y empleados, de forma que tengamos una ficha para cada uno de ellos.
Crear un formulario basado en fichas es una tarea sencilla, y lo único que hay que hacer es
indicar en la propiedad Canvas Type que el tipo de canvas es del tipo Tab. Esto creará un
formulario con dos fichas o páginas por omisión. Si desea añadir más páginas, basta con pulsar el
icono Crear objeto del Explorador de objetos. Una vez creado el canvas cambiaremos su nombre
a FICHA y modificaremos algunas de las propiedades de la fichas, como son el nombre y la
etiqueta (p.e. Departamentos y Empleados).

A continuación crearemos los bloques de datos para cada una de las fichas, y este proceso es
similar al que se siguió en su momento para crear el formulario Maestro-Detalle. Lo único que
hay que tener en cuenta ahora en el Asistente para diseño (Layout Wizard) es situar el bloque de
datos en la ficha correspondiente, tal y como se muestra en la figura siguiente.
NOTA: Si tiene problemas al ejecutar la consulta y sólo puede consultar por la parte detalle,
cambie el orden de los bloques de datos, ya que siempre se pregunta por el que está en primer
lugar.
Figura. Asignación de un bloque de datos a una ficha de un canvas.

Al final, su formulario deber ser similar al de la figura siguiente
Figura. Formulario basado en fichas.

Pese a que este ejemplo es un poco forzado, piense en las posibilidades que ofrecen este tipo de
formularios, como puede ser el de presentar en una ficha información resumida y en otra ficha
información más detallada.
Además, recuerde que multiplica el espacio útil del formulario por el número de fichas que tenga
su formulario

Guía Estudio Practica 5 SQL

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guía Estudio Practica 5 SQL

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD TECNOLOGICA NACIONAL - FACULTAD REGIONAL MENDOZA

CATEDRA: GESTION DE DATOS - INGENIERIA EN SISTEMAS DE INFORMACION

ENTORNO TEÓRICO, MANUAL DE SQL

Guia estudio práctica 5-GD-2019 Página 1

Proceso de las instrucciones SQL

El código SQL consta de los siguientes elementos:

Guia estudio práctica 5-GD-2019 Página 2

Pasos para implementar una base de datos1:

Guia estudio práctica 5-GD-2019 Página 4

 CREACIÓN DE BASES DE DATOS

Ejemplo parámetros de Oracle:

Tipo de archivo Extensión de nombre de archivo recomendada

Guia estudio práctica 5-GD-2019 Página 5

Guia estudio práctica 5-GD-2019 Página 6

Guia estudio práctica 5-GD-2019 Página 7

Descripción Tipos Estándar SQL Oracle SQL

Guia estudio práctica 5-GD-2019 Página 8

- Datos de gran tamaño

Guia estudio práctica 5-GD-2019 Página 9

Tipo: INTEGRIDAD DE ENTIDAD O TABLA

Guia estudio práctica 5-GD-2019 Página 10

Tipo: INTEGRIDAD DE ENTIDAD O TABLA

Tipo: INTEGRIDAD REFERENCIAL

Guia estudio práctica 5-GD-2019 Página 11

Como se observa en la sintaxis, se puede indicar un valor por defecto al dominio e

CREATE TABLE departamentos ( CREATE TABLE localidadDept (

Guia estudio práctica 5-GD-2019 Página 12

Tabla para ejemplos de sentencia ALTER TABLE.

Guia estudio práctica 5-GD-2019 Página 13

Elimina la columna indicada de manera irreversible e incluyendo los datos que

Guia estudio práctica 5-GD-2019 Página 14

(5) Modificar columna. Permite cambiar el tipo de datos y propiedades de una

Los cambios que se permiten son (en Oracle):

Ejemplo: ALTER TABLE facturas RENAME COLUMN fecha TO fechaYhora;

Guia estudio práctica 5-GD-2019 Página 15

El DML (Data Manipulation Language) lo forman las instrucciones capaces de

Guia estudio práctica 5-GD-2019 Página 16

Agreguemos instancias a nuestras tablas creadas desde el SQLDeveloper en la

Guia estudio práctica 5-GD-2019 Página 17

Se modifican las columnas indicadas en el apartado SET con los valores

Guia estudio práctica 5-GD-2019 Página 18

Otras instrucciones DDL

Ejemplo: CREATE INDEX nombre_completo ON empleados (apellido1, apellido2, nombreP);

Guia estudio práctica 5-GD-2019 Página 19

Guia estudio práctica 5-GD-2019 Página 20

Guia estudio práctica 5-GD-2019 Página 21

Guia estudio práctica 5-GD-2019 Página 22

DQL es la abreviatura del Data Query Language (lenguaje de consulta de datos) de

Guia estudio práctica 5-GD-2019 Página 23

- * El asterisco significa que se seleccionan todas las columnas

La sintaxis completa de la instrucción SELECT es compleja, pero la voy resumir como

Guia estudio práctica 5-GD-2019 Página 24

Guia estudio práctica 5-GD-2019 Página 25

Guia estudio práctica 5-GD-2019 Página 26

En el caso de nuestro ejemplo, la evaluación de la consulta se realiza como sigue:

...las expresiones de la cláusula SELECT se evalúan así:

Para la segunda fila...

...las expresiones de la cláusula SELECT se evalúan así:

Para la tercera fila..

...las expresiones de la cláusula SELECT se evalúan así:

Finalmente, para la cuarta y última fila...

Guia estudio práctica 5-GD-2019 Página 27

...las expresiones de la cláusula SELECT se evalúan así: