Documente Academic
Documente Profesional
Documente Cultură
__________________________________________________________________________________________
Para tener acceso a cualquier manejador de base de datos relacional, es necesario el uso de
SQL es un lenguaje no procedimental, el cual se caracteriza, por no requerir (de parte del
desarrollador), información sobre la ubicación física de los archivos, es decir, indicarle la ruta de
SQL, viene dada en poder accesar a múltiples registros a la vez, con el uso de una sola instrucción.
Por lo antes expuesto se puede inferir que al usuario de la base de datos, le es indiferente el
Para que los usuarios y programadores puedan tener acceso a SQL, ORACLE ofrece un
conjunto de herramientas, entre las cuales está SQL*Plus, el cual permite usar interactivamente los
comandos de SQL o los bloques de PL/SQL, con el objeto de escribir comandos en linea, o
producir reportes, que nos permitirán consultar la información almacenada en la base de datos, sin
Tabla:
Es la estructura básica de almacenamiento de datos, en un sistema manejador de base de datos
relacional. Una tabla consiste de una o más unidades de información (filas), donde cada una de
ellas, contiene un mismo tipo de valores (columnas).
Columna:
Es un campo que representa un tipo o atributo de datos en una tabla.
Fila:
Son las ocurrencias o registros de las tablas.
Valor:
Es el dato existente, entre el cruce de una columna y una fila
Vista:
Es un objeto de la base de datos que muestra una representación lógica de una o varias tablas. Esta
se deriva de una tabla pero no tiene su propio almacenamiento. Su manejo es similar a una tabla.
Sistema de manejo de base de datos relacional:
Es un programa de computadora de propósito general, para el almacenamiento y recuperación de
datos, donde los datos están organizados en tablas y pueden ser relacionados unos con otros.
CHAR:
Son caracteres basados en letras mayúsculas y minúsculas, números, y signos especiales tales
como "@", "#", "%", etc. El ancho máximo de este tipo, en caracteres, no debe ser mayor de 255.
Ejemplo: CHAR(10).
DATE:
Puede almacenar valores de tipo hora y de tipo fecha; éstas últimas van, desde el 1ero de enero de
4.712 antes de Cristo, al 31 de diciembre de 4.712 después de Cristo.
LONG:
Similar a CHAR, pero puede almacenar 65.535 bytes de longitud.
Restricciones:
- No se puede usar más de una columna tipo long por tabla.
- No puede usarse para hacer un JOIN de tablas con una columna de tipo LONG.
- No se puede emplear una columna de tipo LONG, para realizar búsquedas.
NUMBER:
Es un valor numérico, el cual consiste de dígitos que van del cero (0) al nueve (9), con los signos
opcionales positivo (+), negativo (-) y punto decimal (.). El máximo valor de NUMBER puede
tener 38 dígitos.
BUFFER SQL:
Es el área donde SQL*PLUS almacena sus más recientes comandos de entrada.
Para tener acceso a la base de datos, usando el lenguaje SQL, lo primero que debemos
hacer, es activar a SQL*Plus. La forma de activarlo es la siguiente:
Una vez conectado a SQL*Plus, aparecerá el prompt el cual indicará que SQL*Plus está activo:
SQL >
Para poder salir de SQL*Plus (en forma permanente), deberá escribir el comando EXIT o
QUIT y aceptar la ejecución. ( Terminará cualquier transacción pendiente )
Ayuda en línea
SQL*Plus ofrece la ayuda en linea, la cual podrá ser activada mediante el comando HELP.
Nota: no siempre éste comando se encuentra disponible, ya que esto dependerá del criterio del
Administrador de la base de datos.
Ejemplos de HELP:
APPEND
Uso: Adiciona texto en el buffer al final de la linea en curso.
Forma abreviada: A
Sintaxis: APPEND Texto
CHANGE
Uso: Realiza cambios en el texto de la linea en curso.
Forma abreviada: C.
Sintaxis: CHANGE separador TEXTO VIEJO [separador [TEXTO NUEVO [separador]]]
CLEAR
Uso: Limpia o borra el valor o selección en curso para una opción específica.
Forma abreviada: CL.
Sintaxis: CLEAR Opción
Opción:
BREAKS:
Remueve las especificaciones realizadas con el comando BREAK.
BUFFER:
Remueve el texto del buffer. Tiene el mismo efecto que CLEAR SQL,
a menos que se utilicen multiples buffers.
COLUMNS:
Remueve los valores impuestos por el comando COLUMN.
COMPUTES:
Remueve las especificaciones realizadas con el comando COMPUTE
SCREEN:
Borra la pantalla.
SQL:
Remueve el texto del buffer de SQL.
DEL
Uso: borra la línea en curso del buffer.
Sintaxis: DEL
INPUT
Uso: adiciona en el buffer una o más lineas de texto inmediatamente después de la linea en curso.
Forma abreviada: I.
Sintaxis para adicionar una linea en el buffer:
INPUT Texto (acceptar comando)
Sintaxis para adicionar una o más lineas en el buffer:
INPUT (acceptar comando)
Texto_1 (acceptar comando)
Texto_2 (acceptar comando)
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
Texto_n (acceptar comando)
(acceptar nuevamente para concluir la adición de lineas al buffer)
LIST
Uso: muestra una o más lineas almacenadas en el buffer de SQL.
Forma abreviada: L.
Sintaxis: LIST [ n | n m | n * | n LAS | * | * n | * LAST | LAST ]
----------------------------------------------------------------------------------------
Nombre de la tabla Descripción
----------------------------------------------------------------------------------------
user_catalog Posee los nombres de las tablas, vistas, sinónimos, secuencias,
de la cual es dueño un usuario.
user_indexes Descripción de los índices pertenecientes a un usuario.
user_sequences Descripción de las secuencias pertenecientes a un usuario.
user_synonyms Descripción de los sinónimos pertenecientes a un usuario
user_ts_quotas Muestra el tamaño máximo que pueden tener las tablas.
user_users Muestra la información acerca del usuario en curso.
user_views Lista las vistas pertenecientes a un usuario.
obj Muestra todos los objetos del usuario activo.
----------------------------------------------------------------------------------------
Nota: Para ver otras tablas o vistas del diccionario de datos accesar las vistas:
DICT, DICTIONARY, CAT , CATALOG
Ejemplo de utilización:
Nota: Los detalles del comando SELECT se discutirán detalladamente en las próximas páginas.
COMANDOS DE SQL
Los comandos de SQL permiten crear, almacenar, cambiar, recuperar, y mantener la información
almacenada en la base de datos de ORACLE.
* Comandos varios.
Comandos varios:
* Describe.
* Host.
* Connect
SELECT:
Esta sentencia muestra una o más filas, con sus respectivas columnas, las cuales pueden ser
extraídas de una o más tablas, vistas o sinónimos. El número de columnas a visualizar puede ser
parcial o total.
SELECT Columnas
FROM Origen_datos
Columnas: son los nombres de todas aquellas columnas que se desea visualizar, los cuales
deberán de estar separados por una coma (,). Si se desean visualizar todas las columnas de la tabla,
se podrá abreviar la operación, colocando en lugar de los nombre de las columnas, un asterisco
(*); adicionalmente puede usarse como columnas de visualización las constantes, operaciones
aritméticas, funciones, nidos de funciones y funciones de grupo.
Origen_datos: son los nombres de todas aquellas tablas, vistas o sinónimos de los cuales se desea
extraer la información, los cuales deberán estar separados por una coma (,).
Selección de columnas
Como se dijo anteriormente se pueden visualizar de forma total o parcial las columnas de una
tabla. A continuación se muestra un ejemplo de cada caso:
Caso 1:
Visualización de todas las columnas de la tabla empleado, usando para ello, los nombres de cada
una de las columnas.
Nota: lo indicado en cursiva pertenece al prompt de SQL, por lo tanto no deberá transcribirse.
Caso 2:
Visualización de todas las columnas de la tabla empleados, usando para ello, el asterisco (*).
Nota: Suponer para este ejemplo que la tabla empleado, tiene las siguientes columnas:
- NOMBRE
- CARGO
- SALARIO
- NUMDEPT
SQL> SELECT *
2 FROM EMPLEADO;
Visualización de la ejecución:
Caso 3:
Visualización de la ejecución:
Si al momento de manipular una tabla, no recuerda los nombres de las columnas o el tipo
al cual pertenecen, se puede usar el comando DESCRIBE el cual facilitará dicha información.
DESCRIBE Origen_datos
Abreviación: DESC
Ejemplo:
Visualización de la ejecución:
Suponga el caso donde se desea conocer, los nombre de todos los cargos de empleados,
que existen en nuestra empresa. Para ello se asume que dicha información no se repetirá. Para
lograr esto debe hacer uso del parámetro DISTINCT, perteneciente a la sentencia SELECT.
La sintaxis es la siguiente:
A continuación se muestra un ejemplo para visualizar todos los cargos que posee nuestra empresa,
sin repetir ningún cargo.
Visualización de la ejecución:
CARGO
---------------------
SECRETARIA
CHOFER
GERENTE
Operadores de selección
- UNION
- INTERSECT
- MINUS
Ejemplo:
Mostrar todos los empleados que ganen más de 20000. Esto se deberá de realizar
para todos los departamentos.
Ejemplo:
Mostrar todos los cargos que sean comunes, para todos los departamentos.
MINUS: Busca las filas que aparezcan en la primera consulta, pero que a su vez, no aparezcan en
a segunda consulta.
Ejemplo:
Mostrar todos los cargos que se encuentren en el departamento EMP_TALLER pero que a su vez,
no se encuentren en el departamento EMP_ADMIN.
Un alias es un nombre temporal que sólo tiene efecto durante la operación en curso, el cual
sustituye a un nombre de tabla o de columna.
- Cuando se manejan dos o más tablas en una operación, y en estas existen columnas de igual
nombre, se crea una ambigüedad, ya que el manejador de la base de datos, no sabrá a que tablas se
está refiriendo. Cuando se pide visualizar, una columna en particular; por tal motivo, se debe usar
un alias de tabla en una de las columnas.
Ejemplo 1:
Ejemplo 2:
Ejemplo 3:
Ejemplo 4:
Selección de filas
La instrucción SELECT, puede entregar múltiples registros o filas, de una o más tablas.
Pero su verdadera utilidad radica en poder hacer una selección de los datos que cumplan con una
determinada condición. Para tal fin, se hará uso del parámetro WHERE.
Nota: para cambiar el orden de precedencia de alguno de los operadores antes mencionados se
deberá hacer uso de los paréntesis "(", ")".
Ejemplo 1:
Mostrar todos los empleados, que pertenezcan al departamento 01 y que devenguen un salario
mayor de 10.000 y el cargo sea GERENTE
SQL> SELECT *
2 FROM EMPLEADO
3 WHERE NUMDEPT = 01
4 AND SALARIO > 20.000
5 AND CARGO = 'GERENTE';
Ejemplo 2:
Mostrar los salarios de todos los empleados que estén entre 10.000 y 20.000.
SQL> SELECT *
2 FROM EMPLEADO
3 WHERE SALARIO BETWEEN 10000 AND 20000;
Ejemplo 3:
Mostrar todos los empleados que devenguen salarios de 10.000, 11.000 y 20.000.
SQL> SELECT *
2 FROM EMPLEADO
3 WHERE SALARIO IN (10000, 11000, 20000);
Ejemplo 4:
Mostrar todos los empleados que tengan en la segunda posición de su nombre la letra "A".
SQL> SELECT *
2 FROM EMPLEADO
3 WHERE NOMBRE LIKE '_A%';
Para usar la cláusula GROUP BY es necesario, que el o los nombres de las columnas que
aparecen en la sentencia SELECT, hallan sido especificadas en la sentencia GROUP BY, o en su
defecto poseer una de las funciones de agrupamiento (explicadas en la sección Tipos de datos y
funciones).
Ejemplo:
Mostrar una lista de todos los cargos que existen por departamento. En dicha lista se
mostrará: número de departamento, cargo y cantidad de cargos similares por departamento.
GROUP BY puede ser acompañado por la cláusula HAVING, siendo su uso no obligatorio, pero
cuando se usa, se debe acompañar de la cláusula GROUP BY. Su función, es la de crear una
condición de agrupamiento; su forma de trabajo es similar a la cláusula WHERE.
Ejemplo:
Realizar el ejemplo anterior, teniendo en cuenta, que esta vez, se realizará la agrupación y
mostrará todos aquellos departamentos cuya cantidad por cargo sea menor de 5.
Ejemplo:
Mostrar todos los empleados del departamento 01, ordenados de la siguiente manera:
- Nombre, cargo y departamento ordenado ascendentemente.
- Salario ordenado descendentemente.
SQL> SELECT *
2 FROM EMPLEADO
3 WHERE NUMDEPT = 01
4 ORDER BY NOMBRE, CARGO, SALARIO DESC, NUMDEPT;
Hasta este momento, hemos ordenado la visualización de una tabla, por medio de los
nombre de las columnas. También podemos realizar esta operación colocando en vez del nombre
de la columna, la posición de la misma. Cuando se indican los nombres de las columnas a
visualizar, la posición de esta, será la misma posición que hemos colocado en la sentencia; pero
cuando se coloca el asterisco (*), para indicar que se visualicen todas las columnas, la posición de
estas será, la misma que elegimos al momento de crear la tabla.
Mostrar la tabla empleados ordenada por la segunda columna, teniendo en cuenta, que la
información deberá aparecer de la siguiente manera:
NOMBRE, SALARIO, CARGO
Ejemplo 2:
Mostrar la tabla empleados ordenada por la segunda columna, teniendo en cuenta, que la
posición de dicha columna, deberá ser la misma que se uso, al momento de crear la tabla.
SQL> SELECT *
2 FROM EMPLEADO
3 ORDER BY 2;
Las sentencias de SQL, permiten hacer diferentes cálculos aritméticos, como lo son los
siguientes (en orden de precedencia):
* MULTIPLICACIÓN.
/ DIVISIÓN.
+ SUMA.
- RESTA.
Nota: a los anteriores se le puede cambiar el orden de precedencia con el uso de paréntesis "(", ")".
Ejemplo:
---------------------------------------------------------------------------------------------------
Funciones numéricas Utilidad
---------------------------------------------------------------------------------------------------
NVL(n, m) Convierte el valor "n", a un valor "m", cuando "n" es nulo.
---------------------------------------------------------------------------------------------------
Funciones de fecha y hora Utilidad
---------------------------------------------------------------------------------------------------
ADD_MONTHS(n, m) Adiciona a "n" la cantidad de meses que indique "m", "m"
puede ser positivo o negativo.
---------------------------------------------------------------------------------------------------
Funciones de caracteres Utilidad
---------------------------------------------------------------------------------------------------
INITCAP(c1) Retorna la primera letra del contenido de "c1",
en mayúsculas, y todas las demás letras en minúsculas.
---------------------------------------------------------------------------------------------------
Funciones de caracteres Utilidad <cont>
---------------------------------------------------------------------------------------------------
SUBSTR(c1, n1, n2) Extrae del contenido de "c1", "n2" caracteres, partiendo
desde la posición "n1".
---------------------------------------------------------------------------------------------------
Funciones de conversión Utilidad
---------------------------------------------------------------------------------------------------
TO_CHAR(d, [f]) Convierte un valor de tipo fecha u hora "d", a un valor de
(Conversión tipo char, pudiendo especificar opcionalmente un formato
de tipo fecha y hora) "f". Si no se especifica el formato "f", por defecto se tomará
"DD-MON-YY". La función de TO_CHAR, es cambiar
la forma de visualización de la fecha u hora.
MODELOS DE FORMATO:
---------------------------------------------------------------------------------------------------
Funciones de agrupamiento Utilidad
---------------------------------------------------------------------------------------------------
AVG(n) Retorna el average de la columna "n", ignorando valores nulos.
---------------------------------------------------------------------------------------------------
Funciones adicionales Utilidad
---------------------------------------------------------------------------------------------------
GREATEST(n, m) Retorna el mayor entre "n" y "m".
DECODE(c, n1, r1, n2, r2) d Retorna el valor "r1", si "c" es igual a "n1",
Retorna el valor "r2", si "c" es igual a "n2",
En caso de no coincidir con ningún valor de la lista
retorna "d". El valor "d" puede omitirse.
Nota: pueden haber tantos n y r como se deseen.
Ejemplo:
Mostrar el número de departamento, el salario más alto, el salario promedio y el total de
salarios por departamento y la información deberá aparecer de la siguiente manera:
Departamento
Del # AL 15000 HAY x# Del 15001 AL 20000 HAY x# Más de 20001 HAY x#
Anteriormente se han elaborado reportes simples, los cuales carecen de ciertos detalles,
como títulos, formato, totalización, etc. Para lograr esto se hará uso de los comandos de
SQL*Plus, lo cual permitirá, crear reportes de mejor calidad, los cuales se podrán visualizar por
TTITLE
Uso: Muestra un título en el tope cada página del reporte.
Forma abreviada: TTI.
Sintaxis: TTITLE [ep [texto | variable ] ] | [OFF | ON ].
ep: ver: especificaciones de impresión.
OFF: desactiva la opción.
ON: activa la opción.
BTITLE
Uso: Muestra un título en el pie de página del reporte.
Forma abreviada: BTI.
Sintaxis: BTITLE [ep [texto | variable ] ] | [OFF | ON ].
ep: ver: especificaciones de impresión.
OFF: desactiva la opción.
ON: activa la opción.
COLUMN
Uso: Sirve para especificar los atributos con los cuales van a ser mostrados una columna, tal como
encabezados de las columnas, alineación, formato de los datos y el manejo de los datos.
Forma abreviada: COL
Sintaxis: COLUMN [{Columna | expresión} [opciones] ].
Opciones:
ALIAS JUSTIFY [ LEFT | CENTER | CENTRE | RIGHT ] OLD_VALUE
CLEAR LIKE PATTERN
COLOR LINEAPP [ LINE | MARK | BOTH] WRAPPED
FOLD_AFTER NEWLINE
FOLD_BEFORE NEW_VALUE
FORMAT NOPRINT
HEADING NULL
BREAK
Uso: Indica cuando y como cambia el formato de impresión en el reporte, tal como, suprimiendo
los valores duplicados para la columna especificada, saltando lineas, al cambiar el valor de la
columna, mostrando cálculos especificados a través de un COMPUTE.
Forma abreviada: BRE
Sintaxis: BREAK [ ON columnas del Select [ acción [ acción]]] ...
COMPUTE
Uso: Permite realizar cálculos e imprimir sumatorias, usando varios cálculos estándares, sobre
subgrupos, de filas seleccionadas.
Forma abreviada: COMP
Sintaxis: COMPUTE [función ...
OFF {expresiones | columna | alias}...
ON {expresiones | columna | alias | REPORT | ROW}]
SET
Uso: Establece los aspectos de ambiente de SQL*Plus, para la sección actual de trabajo, tales
como:
- Fija los atributos del display para los datos numéricos LONG, CHAR y DATE; definición
de tamaño de página PAGESIZE, linea LINESIZE, arreglos de memoria ARRAYSIZE,
espaciado entre columnas SPACE, etc.
- Fija los atributos para los parámetros de ambiente tales como impresión de encabezados,
cubierta, salidas a pantallas, pie de página, mensajes, etc.
Sintaxis: SET variable del sistema.
ECHO
Uso: Cuando está activo, muestra los comandos que están siendo ejecutados. Caso contrario
cuando esta desactivado.
Sintaxis: ECHO {OFF | ON}
FEEDBACK
Uso: Muestra el número de registros retornados por una consulta, cuando la misma selecciona un
mínimo de "n" registros.
Cuando se coloca ON, "n" será igual a uno. Cuando se coloca OFF, "n" será igual a cero; por
defecto "n", vale 6.
Forma abreviada: FEED.
Sintaxis: FEEDBACK {6 | n | OFF | ON}
n: es el mínimo número de registros que debe procesar la instrucción para ser mostrado el
FEEDBACK
NULL
Uso: Selecciona un texto que representará a los valores nulos. Por defecto este será espacio.
Sintaxis: NULL texto
PAGESIZE
Uso: Selecciona el número de lineas por páginas
Forma abreviada: PAGES
Sintaxis: PAGESIZE {14 | n}
SPACE
Uso: Selecciona el número de espacios entre columnas.
Forma abreviada: SPA.
Sintaxis: SPACE {1 | n}
ESPECIFICACIONES DE IMPRESIÓN
COL
Uso: Hace que el próximo valor de tipo CHAR, aparezca en la columna "n" de una linea.
Sintaxis: COL n
SKIP
Uso: Salta hacia una nueva linea "n" veces. Si n es mayor que 1, n-1 lineas en blanco aparecerán
después del próximo valor de tipo carácter.
Sintaxis: SKIP n
TAB
Uso: Salta "n" columnas hacia adelante o hacia atrás dependiendo si el valor de "n" es positivo o
negativo. Columnas se refiere a posición de impresión.
Sintaxis: TAB n
LEFT
Uso: Alinea un valor de tipo char a la izquierda.
Sintaxis: LEFT
CENTER
Uso: Alinea un valor de tipo char al centro.
Sintaxis: CENTER
RIGHT
Uso: Alinea un valor de tipo char a la derecha
Sintaxis: RIGHT
BOLD
Uso: Imprime los datos en negrita
Sintaxis: BOLD
FORMAT
Uso: Especifica el modelo de formato o máscara en el cual se mostrarán los datos de la columna
especificada.
Sintaxis: FORMAT máscara o formato.
- START nombre.sql
- @nombre.sql
SET PAUSE ON
SET PAGESIZE 24
SET ECHO OFF
SET FEEDBACK OFF
TTITLE RIGHT 'PAGINA' SQL.PNO SKIP 2 -
CENTER 'REPORTE DE PERSONAL' SKIP 2 -
CENTER 'Producido por el departamento de personal' SKIP 2
BTITLE CENTER 'Información confidencial'
COLUMN DEPTNO HEADING 'DEPARTAMENTO' FORMAT 99
COLUMN NOMBRE FORMAT A10
COLUMN CARGO FORMAT A10
COLUMN SALARIO HEADING 'SALARIO|MENSUAL' FORMAT $99,990.00
COLUMN ANUAL HEADING 'SALARIO|ANUAL' FORMAT 999,990.00
SET SPACE 6
BREAK ON NUMDEPT SKIP 2 ON REPORT
COMPUTE SUM AVG OF SALARIO ON NUMDEPT REPORT
COMPUTE STD OF ANUAL ON NUMDEPT REPORT
SET NULL 'DESCONOCIDO'
SELECT NUMDEPT, NOMBRE, CARGO, SALARIO, SALARIO*12 ANUAL
FROM EMPLEADO
ORDER BY NUMDEPT
PAGINA 1
REPORTE DE PERSONAL
SALARIO SALARIO
DEPARTAMENTO NOMBRE CARGO MENSUAL ANUAL
----------------------- ---------------- ------------------ ---------------------- ---------------------------
10 PEDRO OBRERO $2,450.00 29,400.00
MANUEL PRESIDENTE $5,000.00 60,000.00
EMILIO GERENTE $1,500.00 18,000.00
TERESA LIMPIEZA $1,300.00 15,600.00
JOSÉ SUB-GERENTE $1,500.00 18,000.00
LUIS PASANTE DESCONOCIDO DESCONOCIDO
CHANG PASANTE DESCONOCIDO DESCONOCIDO
INGRID SECRETARIA $2,000.00 24,000.00
CARMEN SECRETARIA $2,550.00 30,600.00
**************** ---------------------- -----------------------------
avg $2,328.57
sum $16,300.00
std 34,824.70
Información confidencial
PAGINA 2
Conceptos Básicos de SQL/PLUS /32
Introducción al Desarrollo de Aplicaciones ORACLE
__________________________________________________________________________________________
REPORTE DE PERSONAL
SALARIO SALARIO
DEPARTAMENTO NOMBRE CARGO MENSUAL ANUAL
----------------------- -------------- ------------------ ---------------------- ----------------------
20 RODRIGO LIMPIEZA $800.00 9,600.00
ISABEL LIMPIEZA $1,100.00 3,200.00
GERARDO ANALISTA $3,000.00 36,000.00
DILIA ANALISTA $3,000.00 36,000.00
LUIS SECRETARIO $2,000.00 24,000.00
PETRONILO GERENTE $2,975.00 35,700.00
**************** ---------------------- ----------------------
avg $2,145.83
sum $12,875.00
std 71,068.05
Información confidencial
PAGINA 3
REPORTE DE PERSONAL
SALARIO SALARIO
DEPARTAMENTO NOMBRE CARGO MENSUAL ANUAL
----------------------- -------------- --------------------- ---------------------- ----------------------
30 TOMAS VENDEDOR $1,600.00 19,200.00
RAQUEL LIMPIEZA $2,850.00 34,200.00
ORLANDO VENDEDOR DESCONOCIDO DESCONOCIDO
GLORIA VENDEDOR $1,250.00 15,000.00
JUDITH VENDEDOR $950.00 1,400.00
MARÍA VENDEDOR $1,500.00 8,000.00
JOSEFINA VENDEDOR $1,250.00 15,000.00
**************** ---------------------- ----------------------
avg $1,566.67
sum $9,400.00
std 55,051.68
Información confidencial
PAGINA 4
REPORTE DE PERSONAL
SALARIO SALARIO
DEPARTAMENTO NOMBRE CARGO MENSUAL ANUAL
-------------------------- -------------- ------------------ ---------------------- ----------------------
------------------------ ----------------------
avg $2,030.26
sum $38,575.00
std 689,055.92
Información confidencial
INSERT permite adicionar una nueva fila, a la tabla especificada; esto se puede hacer con
todas las columnas (colocando los valores de todas las columnas en el mismo orden de la tabla) o
con algunas columnas (colocando después del nombre de la tabla, el nombre de las columnas en
las cuales se desea insertar la información y después de VALUES, los valores que tendrán estas).
Ejemplo 1:
Insertar una nueva fila, (con todas sus columnas), a la tabla empleado.
Ejemplo 2:
Insertar una nueva fila, (con las columnas nombre y salario), a la tabla empleado.
Ejemplo 3:
Insertar una nueva fila, (con las columnas nombre y fecha), a la tabla cumpleaños.
Nota: cumpleaños será reemplazado por cumpleanos, para evitar problemas con SQLPLUS.
Ejemplo 4:
Insertar una o más fila, a la tabla empleado usando las columnas nombre y salario, donde el
sistema, sea el que pida los valores de cada columna, gracias al uso de & para crear variables.
Ejemplo 5:
Insertar una o más fila, a la tabla empleado usando las columnas nombre y salario tomando datos
de otra tabla.
SQL > INSERT INTO EMPLEADO (NOMBRE, SUELDO)
2 SELECT NOMBRE, SUELDO * 1.25 FROM EMPLEADO_VIEJO;
Imaginese el caso, que una vez impreso un reporte, hemos detectado un error en los datos
del mismo y por lo tanto deseamos corregirlo, es aquí donde entra en juego el comando UPDATE.
UPDATE nombre_de_la_tabla
SET columna1 = valor, columna2 = valor...
[WHERE condición]
Ejemplo 1:
Aumentar el salario un 20% a todos los empleados del departamento 01.
Ejemplo 2:
Aumentar el salario un porcentaje a todos los empleados, usando un porcentaje por departamento.
Ejemplo 3:
Aumentar el salario con el 10 % del promedio de salarios de su departamento.
Para poder borrar una fila o un conjunto de filas se hará uso del comando DELETE
Ejemplo 1:
Eliminar los empleados del departamento 02
Ejemplo 2:
Eliminar los empleados que tengan un salario mayor del promedio de salarios de su departamento.
Transacción
Se considera como una transacción, todos aquellos cambios realizados a la base de datos,
una vez ejecutado el comando COMMIT.
COMMIT guarda en forma "permanente", todos los cambios realizados a la base de datos.
------------------ COMMIT
|
| INSERT...
|
| DELETE...
TRANSACCIÓN |
| UPDATE...
|
| INSERT...
|
------------------ COMMIT
La contra parte de COMMIT, es ROLLBACK. Esta instrucción ignora todos los cambios
realizados a la base de datos, excepto si previamente se ha realizado un COMMIT.
------------------ COMMIT
|
| INSERT...
TRANSACCION |
| DELETE...
|
| ---------------- ROLLBACK
|
TRANSACCION | UPDATE...
|
| INSERT...
|
------------------ COMMIT
Existe también una forma de ignorar, parcialmente los cambios realizados a la base de
datos. Esto se logra introduciendo marcas, que tienen como finalidad, informar al comando
ROLLBACK, hasta donde deben ser ignorados, los cambios efectuados a la base de datos. La
forma de realizar estas marcas, es por medio del comando SAVEPOINT.
------------------ COMMIT
|
| INSERT...
|
| SAVEPOINT A
|
| DELETE...
TRANSACCION |
| UPDATE...
|
| ROLLBACK TO SAVEPOINT A
|
| INSERT...
|
------------------ COMMIT
Sintaxis:
CREATE TABLE [usuario.]nombre_de_la_tabla
({nombre_de_columna tipo | tabla_de_integridad}
[, {{nombre_de_columna tipo | tabla_de_integridad}]...)
STORAGE (Initial nK Next nK Pctincrease n Maxextents n Minextents n);
Reglas de integridad
PRIMARY KEY
Es la columna o conjunto de columnas, que permite la identificación única, de cada fila de la tabla;
llamadas claves primarias.
CHECK
Es la definición de la regla del negocio, las cuales involucran columnas contra valores constantes.
FOREIGN KEY
Es la columna o conjunto de ellas, que establecen una relación con una clave primaria de otra
tabla. Esto indica, que para el conjunto de columnas, de la fila de la tabla "A", debe existir, el
mismo conjunto de columnas y valores en la tabla "B".
[NOT] NULL
Permite validar que la columna pueda tener o no, valores nulos, en otras palabras, si la columna es
mandatoria.
UNIQUE
Es la columna o conjunto de ellas, que permiten una identificación única alterna, de cada fila de la
tabla, llamadas claves secundarias o alternas.
REFERENCES
Es una clave foránea de una columna simple.
Reglas de STORAGE
Indica el almacenamiento con que trabajará la tabla que vaya a ser creada, basado en el tamaño de
la extenciones o anexos de espacio (extents).
Initial Indica el espacio inicial de creación de la tabla (Primer Extents)
Next Segundo extents a ser asignado a la tabla.
Pctincrease Porcentaje de incremento para entre los extents requeridos por la tabla
a partir del tercero.
Maxextents Es la cantidad máxima de extents que puede crecer una tabla.
Minextents Es la cantidad mínima necesaria de extents para poder crear la tabla.
Ejemplo 1:
Crear una tabla llamada EMPLEADO2, con las columnas:
- CODIGO
- NOMBRE
- CARGO
- CODJEFE
- SALARIO
- NUMDEPT
Ejemplo 2:
Crear una tabla llamada EMPLEADO3, basada en EMPLEADO2.
Los nombres de las columnas serán:
NOMBRE, SALARIO
La sentencia ALTER TABLE, permite alterar las siguiente definiciones de una tabla:
- Modificar las definiciones de una columna (CHAR, NUMBER, NOT NULL, etc.).
Ejemplo:
SQL > ALTER TABLE DEPARTAMENTO
2 ADD (CODJEFE NUMBER(4)
3 REFERENCES EMPLEADO(CÓDIGO) CONSTRAINT EMP_FK);
Ejemplo:
SQL > ALTER TABLE DEPARTAMENTO
2 DROP CONSTRAINT EMP_FK;
Sintaxis:
RENAME tabla_vieja
TO tabla_nueva
En el caso de querer remover una columna de una tabla, debemos hacer uso de nuestra
imaginación y conocimientos antes adquiridos.
Ejemplo:
La forma de crear una vista es la misma que se utiliza para crear una tabla, pero utilizando una
instrucción SELECT accesando columnas de una o varias tablas.
Ejemplo;
Crear una visión de los datos de la table empleado para el departamento 10
La forma de visualizar una vista es la misma que se utiliza para visualizar una tabla. (Se utilizan
los mismos parámetros de la sentencia SELECT).
Ejemplo:
SQL > CREATE VIEW VISTA_EMP2
2 AS SELECT NOMBRE, CARGO
3 FROM EMPLEADO
4 WHERE NUMDEPT = 01
5 WITH CHECK OPTION;
De esta manera cuando intentemos realizar una actualización no permitida tendremos lo siguiente:
Este error se debe, a que la vista creada, sólo permite visualizar a los empleados del
departamento 01. Si este cambio se hubiese efectuado, no se podría observar los cambios
realizados en la tabla, dando a pensar, que se eliminó la información, cosa que sería falso.
Sólo se pueden modificar valores sobre aquellas vistas que sean sobre una sola tabla y que
no involucren funciones de grupo, columnas artificiales 0u operadores.
El DBA y los dueños de tablas son los únicos que pueden otorgar privilegios a otros
usuarios para que puedan visualizar, modificar o borrar, un objeto de la base de datos (tablas,
vistas, etc.). Estos privilegios se otorgan o quitan por medio del comando GRANT.
Sintaxis:
GRANT {privilegio_del_objeto [, privilegio_del_objeto] ... } | ALL [ PRIVILEGES]}
ON [usuario.]objeto
TO {usuario | PUBLIC } [, usuario]...
[WITH GRANT OPTION]
- Para las tablas: ALTER, DELETE, INDEX, INSERT, REFERENCES, SELECT o UPDATE.
Ejemplo 1:
Otorgar todos los privilegios de la tabla empleado, a todos los usuarios de la base de datos.
SQL > GRANT ALL
2 ON EMPLEADO
3 TO PUBLIC;
Ejemplo 2:
Otorgar el privilegio SELECT al usuario system, permitiéndole a este, otorgar dicho privilegio a
otros usuarios.
SQL > GRANT SELECT
2 ON EMPLEADO
3 TO SYSTEM
4 WITH GRANT OPTION;
Sinónimos:
Los sinónimos son nombres por medio de los cuales, se puede hacer referencia a una tabla
o vista. Estos se utilizan por razones de seguridad y conveniencia, teniendo las siguientes ventajas:
- Referenciar una tabla o vista, sin tener que especificar el dueño de la misma.
- Referenciar una tabla o vista, sin tener que especificar la base de datos en donde la tabla o la
vista existe.
PUBLIC: indica que el sinónimo, podrá ser utilizado por todos los usuarios. Por defecto sólo
podrá ser utilizado por el usuario que creó el sinónimo.
Ejemplo:
El acceso a los datos contenidos en las tablas, puede ser de dos formas:
Los índices son estructuras opcionales, los cuales están asociados a tablas, con la finalidad
de aumentar la velocidad de las consultas y evitar la duplicidad de filas. Cada tabla puede tener un
número ilimitado de índices. La regla para escribir el nombre de un índice, es similar al de una
tabla, pero es recomendable colocar como prefijo, la letra "I" a todo nombre de índice.
Si Ud. anticipadamente sabe que se va a recuperar un poco menos del 15%, de las filas contenidas
en una gran tabla, cuyas columnas van a ser frecuentemente referenciadas por una cláusula
WHERE, entonces Ud. deberá de crear un índice.
Sintaxis:
CREATE [UNIQUE] INDEX índice ON
tabla (columna [ASC | DESC] [, columna [ASC | DESC]] ...)}...
STORAGE (.... ... ... );
UNIQUE: indica que las columnas involucradas, deben contener valores únicos.
índice: nombre del índice a crear
tabla: nombre de una tabla existente, a partir de la cual se creará un índice.
ASC / DESC: crea los índices en forma ascendente o descendente.
columna: nombre de la columna por la cual se va a ordenar.
Nota: el número máximo de columnas concatenadas, que se puede tener en un índice simple, es de
16.
Ejemplo 2:
SQL > CREATE UNIQUE INDEX I_EMPLEADO
2 ON EMPLEADO(NOMBRE);
Ejemplo:
SQL > DROP INDEX I_EMPLEADO;
Validación de índices:
Los problemas de hardware, pueden en ocasiones corromper los índices de una tabla. Para
verificar que los índices no estén corrompidos se hace uso de VALIDATE INDEX.
Sintaxis:
VALIDATE INDEX nombre_del_indice
Ejemplo:
SQL > VALIDATE INDEX I_EMPLEADO;
Secuencias
Las secuencias son estructuras opcionales, su finalidad es generar números enteros únicos,
los cuales pueden ser utilizados por múltiples usuarios. Una utilidad que se le puede dar a una
secuencia, es la de generar automáticamente los números de una clave primaria. La regla para
escribir el nombre de una secuencia, es similar al de una tabla, pero es recomendable colocar como
prefijo, la letra "S" a todo nombre de secuencia.
Sintaxis:
CREATE SEQUENCE secuencia
[INCREMENT BY {1|n}]
[START WITH n]
[ {MAXVALUE n | NOMAXVALUE}]
[ {MINVALUE n | NOMINVALUE}]...
START WITH: es el número con el cual se comienza la secuencia. Por defecto cuando es
ascendente será igual a MINVALUE y cuando es descendente será igual a MAXVALUE.
Ejemplo:
SQL > CREATE SEQUENCE S_DEPARTAMENTOS START WITH 200;
Sintaxis:
DROP SEQUENCE nombre_de_secuencia
Ejemplo:
SQL > DROP SEQUENCE S_DEPARTAMENTOS;
JOIN: es la forma del comando SELECT para combinar filas de dos o más tablas.
Tipos de JOIN
- Simple
- Equijoin (usando una condición de igualdad).
- non-equijoin (usando varias condición de igualdad ú otras).
- Externo
- A si mismo.
Join simple
Retorna filas de dos o más tablas combinadas, a través de una condición de igualdad.
Sintaxis:
SELECT [tabla.]columna, [tabla.]columna...
FROM tabla1, tabla2...
WHERE [tabla1.]columna = [tabla2.]columna
Join externo
Retorna el contenido de un join simple, más, el contenido de las filas de una tabla que no
hallan podido ser combinado en la otra tabla.
Sintaxis:
Ejemplo:
Join a si mismo
Ejemplo:
Obtener una lista de empleados, en la cual se especifique el nombre de su jefe inmediato.
Sub-query (sub-consulta).
Las sub-consultas seleccionan filas de una tabla con una condición que depende de valores
de otra tabla.
Las sub-consultas deben aparecer en la cláusula WHERE de una de las siguientes sentencias:
- SELECT
- INSERT
- UPDATE
- DELETE
Sintaxis:
SELECT ...
FROM ...
WHERE ...
(SELECT ...
FROM ...
WHERE ...);
Ejemplo:
SQL > SELECT *
2 FROM DEPARTAMENTO
3 WHERE NUMDEPT = (SELECT MAX(NUMDEPT)
4 FROM EMPLEADO
5 WHERE CARGO = 'SECRETARIA');
Las sub-consultas de filas múltiples, retornan más de un valor para completar la condición
de la cláusula WHERE.
Ejemplo:
Para escribir instrucciones optimas, se debe tener conocimiento del funcionamiento del
optimizador de SQL. El optimizador realiza un plan de ejecución, el cual considera que será
eficiente basado en factores tales como:
Reglas de construcción:
Ejemplo:
Reducen la cantidad de filas retornadas por instrucción del total de filas de la tabla,
permitiendo ademas el uso de índices.
Ejemplo:
WHERE nombre = 'MIGUEL'
and Salario > 10000
and Codigo_departamento = 10
Buscara todos los departamentos 10 cuyo salario sea mayor de 10000 y el nombre sea
MIGUEL.
Reducen la cantidad de valores por fila retornados de la tabla, si las columnas mencionadas
existen en los índices, la instrucción no necesitara ir a los datos. El uso del (*) como indicador
de selección de todas las columnas es menos eficiente que indicar los nombres de las columnas y
el orden en que fueron creadas.
Ejemplo:
SELECT *
Ejemplo:
SELECT numero_del_empleado, codigo_del_departamento, primer_nombre,
primer_apellido
FROM empleados_compania
Al construir JOINS con muchas tablas y nombres de columnas o tablas iguales es necesario
y recomendable el uso de alias o preposiciones. Esta regla permite utilizar menos caracteres en el
texto de la instrucción, lo que involucra menos tiempo de interpretación (PARSE).
Ejemplo:
SELECT a.codigo_departamento, b.nombre_departamento, a.nombre empleado
FROM empleados a, departamentos b
WHERE a.codigo_departamento = b.codigo_departamento
SELECT empleados.codigo_departamento,
departamentos.nombre_departamento,
empleados.nombre empleado
FROM empleados a, departamentos b
WHERE empleados.codigo_departamento =
departamentos.codigo_departamento
Ejemplo:
WHERE numero_empleado = 10 or
numero_empleado = 20 and codigo_departamento = 10 or
salario > 10000 and codigo_departamento = 20
Seria mejor si
WHERE numero_empleado = 10 or
(numero_empleado = 20 and codigo_departamento = 10) or
(salario > 10000 and codigo_departamento = 20)
Conceptos Básicos de SQL/PLUS /55
Introducción al Desarrollo de Aplicaciones ORACLE
__________________________________________________________________________________________
Las columnas con mayor acceso deben ser las primeras, tales como Claves Primarias,
Claves Alternas, Claves Foráneas; si existe alguna columna que acepte valores nulos
debe ir de última.
Las columnas que se modifican mucho deben tener precedencia a las de valores nulos.
Ejemplo:
CREATE TABLE emp (nro_emp number(4) not null PRIMARY KEY,
cod_depto number(2) not null REFERENCE depto,
nombre char(30) not null,
apellido char(30) not null,
salario number(12,2) not null,
direccion char(90) not null,
nro_jefe number(4) REFERENCE emp,
comision number(12,2),
bonificacion number(12,2),
fotografia long raw);
- La prioridad de las columnas debe venir dado de las columnas con mayor cantidad
de valores reales a la de menor.
Ejemplo:
CREATE UNIQUE INDEX i_emp1 ON emp (nro_emp);
CREATE INDEX i_emp2 ON emp (nombre, apellido);
CREATE INDEX i_emp3 ON emp (cod_deptno, salario)
CREATE INDEX i_emp4 ON emp (salario, comision)
.- Parámetros de Almacenamiento
Lo principal es conocer la cantidad de filas que va almacenar una tabla y en base a esto la
cantidad de bytes a reservar para los datos, evitando crecimiento descontrolados, fraccionados y
dispersos, tratando de mantener los datos en espacios continuos y con privilegios de acceso
rápido (Discos más rápidos). Estimar crecimientos y si es posible reservar el espacio con
anterioridad.
Determinar los grados de volatibilidad y actualización de los datos, para así poder sacar
mejor provecho de los bloques de datos. (PCTUSED y PCTFREE).
Utilización de Indices
- Columnas cuyo porcentaje de valores iguales sea mayor al 20% del total de filas de la
tabla.
Ineficiente al lado de
Las Actualizaciones serán lentas si existe un índice, pero si el volumen de acceso sobre
este índice es superior y es bien aprovechado se deben pesar, que es más importante
actualizaciones rápidas o lecturas rápidas.
Ejemplo:
a la semana
Los índices serán usados según su especificación en la cláusula WHERE y al peso que
tenga la evaluación que se este realizando.
Conceptos Básicos de SQL/PLUS /58
Introducción al Desarrollo de Aplicaciones ORACLE
__________________________________________________________________________________________
Si existen durante la misma evaluación índices con el mismo rango y son índices simples,
serán usados todos los del menor rango.
Lo principal en un JOIN de muchas tablas es determinar cual debe ser la ruta de acceso a
los datos.
Ejemplo:
SELECT
EJ: Visualizar todos los vuelos que tengan como origen o destino Cáceres.
SELECT *
FROM VUELOS
WHERE ORIGEN='CACERES'
OR DESTINO='CACERES'
EJ: Visualizar todos los vuelos que tengan como origen Madrid o Londres y como destino Londres o Madrid.
SELECT *
FROM VUELOS
WHERE (ORIGEN='MADRID'
AND DESTINO='LONDRES')
OR (ORIGEN='LONDRES'
AND DESTINO='MADRID')
Claúsula IN
EJ: Seleccionar aquellos vuelos que tengan como origen Madrid, Barcelona o Sevilla.
SELECT *
FROM VUELOS
WHERE ORIGEN IN ('MADRID','BARCELONA','SEVILLA')
ó también
SELECT *
FROM VUELOS
WHERE ORIGEN='MADRID' OR ORIGEN='BARCELONA' OR ORIGEN='SEVILLA'
EJ: Visualizar todos los vuelos existentes excepto aquellos que llegan a Londres o a Copenhague.
SELECT *
FROM VUELOS
WHERE DESTINO NOT IN ('LONDRES','COPENHAGUE')
Claúsula BETWEEN
SELECT *
FROM VUELOS
WHERE HORA_SALIDA BETWEEN '06.00.00'
AND '12.00.00'
ó también
SELECT *
FROM VUELOS
WHERE HORA_SALIDA >= '06.00.00'
AND HORA_SALIDA <= '12.00.00'
EJ: En la columna NUM_VUELO representaré los vuelos con 6 caracteres. Los dos primeros caracteres
indicarán la compañía a la que pertenece cada vuelo (IB®Iberia, BA®British Airways), los cuatro caracteres
siguientes corresponderán al número de vuelo. Bajo estas condiciones recupérense todos los vuelos que no
pertenecen a IBERIA.
SELECT *
FROM VUELOS
WHERE NUM_VUELO NOT BETWEEN 'IB0000'
AND 'IB9999'
Claúsula LIKE
Sirve para especificar, con la ayuda de metasímbolos, cadenas de caracteres que comparten ciertos
caracteres en común. Los metasímbolos que serán utilizados son:
SELECT *
FROM VUELOS
WHERE NUM_VUELOS LIKE 'IB%'
ó también
SELECT *
FROM VUELOS
WHERE NUM_VUELOS LIKE 'IB_ _ _ _'
Expresiones aritméticas
+, -, *, /
Pueden ser utilizadas tanto después de SELECT como después de WHERE. En el primer caso trabajarían
sobre columnas y en el segundo sobre filas.
EJ: Visualizar la longitud y la envergadura de todos los aviones, expresando las magnitudes en pies (en la
base de datos está almacenado en metros, para pasar 1 metro a pies se ha de multiplicar por 3.28), y la
velocidad de crucero en mph(está en Km/h, habrá que dividir por 1.6).
En DB/2 de IBM las etiquetas toman los nombres de las columnas (col1, col2, col3)
En SQL-SERVER las etiquetas quedarían así (LONGITUD*3.28, ENVERGADURA*3.28, VELO_CRUC/1.6)
EJ: Seleccionar aquellos aviones cuya longitud supere a su envergadura en más de un 10%.
SELECT *
FROM AVIONES
WHERE LONGITUD > ENVERGADURA*1.10
Funciones de columna
Son funciones que operan con todas las filas que cumplen la condición expuesta en la claúsula WHERE. Su
resultado es un único valor. Sintaxis:
Funciones
<f_columna>:
A B
3 5
2 8
3 7
4 3
COUNT(A)=COUNT(B)
COUNT(A)=4, COUNT(B)=4
El COUNT de dos columnas de una misma tabla es igual. COUNT(*) sirve para obtener el nº de filas.
EJ: Seleccionar los valores mínimo y máximo de la columna que almacena las velocidades de crucero.
La función de columna sólo podrá especificarse detrás de la particula SELECT o en la claúsula HAVING, pero
nunca dentro de la claúsula WHERE.
EJ: Se desea saber cuál es el vuelo que tiene la mínima hora de salida.
SELECT *
FROM VUELOS
WHERE HORA_SALIDA=(SELECT MIN(HORA_SALIDA) FROM VUELOS)
Sirve para dividir una tabla en grupos de filas que comparten características comunes. La sintaxis es:
EJ: Efectúese una SELECT que visualice el mínimo valor de hora de salida para cada uno de los diferentes
destinos.
SELECT MIN(HORA_SALIDA)
FROM VUELOS
WHERE DESTINO LIKE '%'
SELECT MIN(HORA_SALIDA)
FROM VUELOS
WHERE DESTINO IN (SELECT DISTINCT DESTINO
FROM VUELOS)
GROUP BY crea una serie de subtablas compuestas por filas con el mismo valor para la columna de
agrupamiento (en este ejemplo la columna DESTINO). Se aplicarán a continuación funciones de columna
sobre cada subtabla de forma independiente.
MADRID, x
BARCELONA, y
SEVILLA, z
EJ: Obtener el origen del vuelo para cada uno de los vuelos que tienen la mínima hora de salida para cada uno
de los destinos.
EJ: Obtener el número de vuelos que existen para cada uno de los orígenes.
Claúsula HAVING
EJ: Visualizar los grupos que tienen para cada uno de los orígenes la mínima hora de salida siendo anterior a
las 12 horas.
EJ: Se desea seleccionar la hora de salida más temprana para cada origen y destino.
SELECT ORIGEN
FROM VUELOS
GROUP BY ORIGEN
HAVING COUNT(*) > 2
EJ: Visualizar los vuelos de IBERIA que tengan más de 150 plazas libres.
ó también
Operaciones aritméticas
Cualquier operación aritmética sobre un campo nulo nos devolverá como resultado un valor nulo.
Tomemos como ejemplo la siguiente tabla:
NULOS
COL_ COL_B
A
15 10
35 35
140 NULL
NULL 100
NULL NULL
7 110
33 60
NULL NULL
NULL NULL
SELECT COL_A+COL_B
FROM NULOS
COL_A+COL_B
25
70
NULL
NULL
NULL
117
93
NULL
NULL
Funciones de columna
SELECT AVG(COL_A)
SELECT SUM(COL_A)/COUNT(*)
AVG(COL_A)=46
SUM(COL_A)/COUNT(*)=25.5
Comparaciones
SELECT *
FROM NULOS
WHERE COL_A=COL_B
COL_A COL_B
35 35
SELECT *
FROM NULOS
WHERE COL_A<>COL_B
COL_A COL_B
15 10
140 NULL
NULL 100
7 110
33 60
SELECT *
FROM NULOS
WHERE COL_A IS NULL
Esta orden visualiza todas las filas en las que el campo perteneciente a la columna COL_A es nulo.
Ordenación
Dependiendo del sistema gestor en uso los valores nulos serán los de mayor o los de menor peso.
DB/2 de IBM:
SELECT COL_A
FROM NULOS
ORDER BY COL_A
COL_A
7
15
33
35
140
NULL
NULL
NULL
NULL
SQL-SERVER:
SELECT COL_A
FROM NULOS
ORDER BY COL_A
COL_A
NULL
NULL
NULL
NULL
7
15
33
33
140
DISTINCT
COL_A
15
35
140
NULL
NULL
7
33
NULL
NULL
Indices únicos
Sobre una columna de índice único sólo está permitida la existencia de un valor nulo.
GROUP BY
COL_A COUNT(*)
15 1
35 1
140 1
NULL 4
7 1
33 1
Todos los valores NULL se agrupan y COUNT devuelve el número de filas que tenían NULL en COL_A.
SUBSELECT
SELECT <lista_columnas>
FROM <lista_tablas>
WHERE <nombre_columna> <CONCATENADOR> (SELECT <nombre_columna>
FROM <lista_tablas>
WHERE <Predicado>)
<CONCATENADOR>
Restricciones: ha de exigirse que el resultado de la Subselect sea un único valor al usar como concatenador
un operador de comparación. Si usamos IN puede devolver más de un valor.
Cada Select se ejecuta una única vez, desde la más interna, hasta la más externa.
EJ: Se desea recuperar las plazas libres que hay en cada vuelo MADRID-LONDRES del día 20/02/92.
{Las plazas libres es un campo de la tabla de reservas. En la tabla de vuelos tenemos el origen y el destino de
cada vuelo.}
SELECT *
FROM RESERVAS
WHERE FECHA_SALIDA='20.02.1992'
AND NUM_VUELO IN(SELECT NUM_VUELO
FROM VUELOS
WHERE ORIGEN='MADRID'
AND DESTINO='LONDRES')
ANY, ALL
Se usan para poder utilizar operadores de comparación con subselects que nos devuelvan más de un valor
único como resultado.
SELECT <lista_columna>
FROM <lista_tablas>
WHERE <nombre_columna> <CONCATENADOR> {ANY/ALL} (<Subselect>)
Una expresión ANY es cierta si lo es para algún valor de los que devuelve la Subselect.
Una expresión ALL es cierta si lo es para todos los valores que devuelve la Subselect.
3>ANY(2,5,7) ® Cierto
3=ANY(2,5,7) ® Falso
3>ALL(2,5,7) ® Falso
3<ALL(9,10,11) ® Cierto
EJ: Se quiere recuperar los aviones cuya longitud sea mayor que la envergadura de todos ellos.
SELECT *
FROM AVIONES
WHERE LONGITUD > ALL (SELECT ENVERGADURA
FROM AVIONES)
ó también
SELECT *
FROM AVIONES
WHERE LONGITUD > (SELECT MAX(ENVERGADURA)
FROM AVIONES)
=ANY e IN tienen la misma función.
Subselects correlacionadas
SELECT <lista_columnas>
FROM <nombre_tabla_externa>
WHERE <nombre_columna> <CONCATENADOR> (SELECT <nombre_columna>
FROM <nombre_tabla_interna>
WHERE <Predicado>)
Las formas de ejecutar una subselect ordinaria y una correlacionadas son diferentes. Las subselects
correlacionadas obedecen al siguiente algoritmo:
ALGORITMO Subselect_Correlacionada
1 Seleccionar fila de tabla externa
2 Ejecutar SELECT interno
3 Evaluar la condición del WHERE externo
- Cierto: la fila seleccionada en 1 será una fila de salida
4 Si existe alguna fila más en la tabla externa ir al paso 1
EJ: Se desea recuperar las reservas cuyo número de plazas libres sea mayor que la media para ese mismo
vuelo.
SELECT *
FROM RESERVAS, A
WHERE PLAZAS_LIBRES > (SELECT AVG(PLAZAS_LIBRES)
FROM RESERVAS
WHERE NUM_VUELO=A.NUM_VUELO)
RESERVAS
IB740 20.02.92 5
IB740 25.02.92 15
IB740 03.03.92 10
AVG(PLAZAS_LIBRES)=10
Alias
Es un sobrenombre que se le da a una tabla y que debe ser único para toda la consulta. Se escribe dejando un
blanco detrás del nombre de la tabla a la cual se va a calificar.
EJ: Se quiere recuperar los aviones que tienen menos de 1 hora y cuarto de recorrido como término medio.
VUELOS
NUM_VUELO VELO_CRUC
............ ............
SELECT *
FROM AVIONES
WHERE 1.25*VELO_CRUC > (SELECT AVG(DISTANCIA)
FROM VUELOS
WHERE NUM_VUELO=AVIONES.NUM_VUELO)
EXISTS-NOT EXISTS
Se define para comprobar la existencia o ausencia del valor devuelto por una Subselect. Una expresión con
EXIST devuelve Cierto si la Subselect nos devuelve al menos un valor.
EJ: Seleccionar toda la información de vuelos para aquellos que tengan origen Madrid y en los que queden
plazas libres.
SELECT *
FROM VUELOS
WHERE ORIGEN='MADRID'
AND EXISTS (SELECT *
FROM RESERVAS
WHERE PLAZAS_LIBRES > 0
AND NUM_VUELO=VUELOS.NUM_VUELO)
EJ: Obtener los tipos de avión y capacidades para aquellos en los que queden menos de 30 plazas libres
(JOIN).
ORDER BY
Se define para ordenar la salida de una consulta por los campos que se especifiquen a continuación.
Sintaxis:
SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY
Ej: Obtener el número de plazas libres que quedan para cada vuelo y ordenar el resultado de más a menos
plazas libres. Para igual número de plazas ordénese por número de vuelo.
Se define para recuperar, usando una única consulta, información que se obtiene a partir de más d una
consulta.
Sintaxis:
<SELECT>
UNION [ALL]
<SELECT>
{UNION[ALL]
<SELECT>}
Características:
- Todas deben ser iguales o compatibles una a una. Esto supone que por cada columna tengamos un único
tipo de dato.
- Pueden ser completas (WHERE, GROUP BY, ...), exceptuando la claúsula ORDER BY, que se ubicará al
final de la última SELECT.
Ej: Sacar una lista de todas aquellas ciudades para las que haya vuelo, ordenadas alfabéticamente.
SELECT ORIGEN
FROM VUELOS
UNION
SELECT DESTINO
FROM VUELOS
ORDER BY 1
Es el alma de un sistema gestor. Se define como un conjunto de tablas que forman una base de datos, y son
definidas y mantenidas automáticamente por el sistema gestor. Sirven para almacenar información sobre los
objetos definidos por los usuarios.
SELECT *
FROM VUELOS
DB2 IBM:
SELECT *
FROM SYSCOLUMNS
WHERE DBNAME='RESERVAS'
Nos da la información sobre todas las columnas que pertenecen a la tabla reservas.
Ej: Crear una vista sobre la tabla vuelos con las columnas ORIGEN y DESTINO para aquellos vuelos que no
sean de IBERIA. Visualizar el contenido de la lista para los vuelos que no partan de Madrid. Borrar la vista.
SELECT *
FROM V_VUELOS
WHERE V_ORIGEN<>'MADRID'
Ej: Visualice los tipos de avión , el doble de su longitud y la mitad de su envergadura, para aquellos aviones
con envergadura mayor que la media y que realizan vuelos desde o hacia Barcelona, ordenándolos de mayor
a menor longitud.
Ej: Visualice las tres primeras letras de los orígenes y destinos de los vuelos realizados por aviones con
longitud mayor con longitud mayor que la media y envergadura menor que 2/3 de la máxima envergadura,
ordenados alfabéticamente por destino.
SUBSTRING (SQL)
(SUBSTRNG), (DB2)
Ej: Visualice el total de plazas libres por número de vuelo para aquellos realizados desde Madrid a Barcelona o
Sevilla y que recorran una distancia mayor que la media de todos los vuelos que salen de Madrid,
ordenándolos de menor a mayor.
Ej: Obtener para cada número de vuelo el total de plazas libres de los vuelos que recorran distancias menores
que 2/3 de la media de las distancias recorridas por vuelos de otras compañías.
Introducción:
AUTORES-LIBROS
Anomalías de modificación: Si Ad.Mig. y Ma.Piat. desean cambiar de editor, se modifica en los 2 lugares. A
priori no podemos saber cuántos autores tiene un libro. Los errores son frecuentes al olvidar la modificación de
un autor. Se pretende modificar en un sólo sitio.
Anomalías de inserción: Se desea dar de alta un autor sin libros, en un principio. NOMBRE y COD_LIB son
campos clave, una clave no puede tomar valores nulos.
Teoría de la normalización:
La teoría de la normalización ofrece una serie de reglas para efectuar una modelización óptima.
En los años 70 Codd creó las bases de la teoría de la normalización. A cada regla de la teoría la denominó
forma normal. Codd creó las formas normales 1ª, 2ª y 3ª. La 3ª forma normal originó problemas. Boyce ayudo
a solventarlos con la f.n. de Boyce-Codd (FNBC). A finales de los 70 Fagin creó las formas normales 4ª y 5ª.
Las formas normales se basan en el concepto de dependencia, que comprende las restricciones definidas
sobre los atributos de una relación. Existen diferentes tipos de dependencia:
Formas normales
1ª forma normal: es una restricción inherente del modelo relacional. Se decie que una tabla está en 1ª forma
normal si no existen en ella grupos repetitivos.
TITULO AUTOR
CyD Ad.Mig.
Ma.Piat.
Hay un grupo repetitivo. De este modo la tabla no es plana y no está en 1ª forma normal. Para convertirla a 1ª
forma normal:
TITULO AUTOR
CyD Ad.Mig.
CyD Ma.Piat.
2ª forma normal: partimos de la idea de dependencia funcional: Un atributo o conjunto de atributos B depende
funcionalmente de A sí y sólo si a cada valor de A le corresponde un único valor de B:
A B
x1 y1
x2 y2
x3 y3
DNI ® NOMBRE
NOMBRE ® DNI
NOMBRE ¨ DNI
Ej: DIRECCION depende funcionalmente de DNI, pero DNI no depende funcionalmente de DIRECCION
DNI ® DIRECCION
Ej: TITULO, LIBRO no dependen funcionalmente de DNI, AUTOR, porque un autor puede escribir varios libros
Sueldo es el atributo implicado que depende de DNI y EMPRESA juntos, que son atributos implicantes.
También:
Las 3 primeras formas normales más la forma normal de Boyce-Codd se basan en dependencias funcionales
obedenciendo al siguiente teorema:
Dada una relación R con un conjunto de atributos A que cumple R(A), x®y, es posible una descomposición en
dos tablas de la siguiente manera:
R(A), x®y
R(x,y) es una relación compuesta por los atributos que forman la dependencia funcional
R(A-y) es una relación compuesta por los atributos de R excluyendo el atributo implicado
Para normalizar la tabla habrá que conocer todas las dependencias funcionales, pero en la relación que nos
den sólo tendremos algunas, a partir de las cuales podremos hallar el resto.
Aplicaremos las propiedades de las dependencias funcionales para obtener todo el conjunto de posibles
dependencias funcionales que puedan existir en la relación.
Al conjunto inicial de depndencias funcionales lo llamaremos F, conjunto a partir del cual obtendremos el resto
de depndencias funcionales. A cada nueva dependencia funcional obtenida a partir de F la llamaré f. Al nuevo
conjunto que contenga todas las dependencias funcionales que obtenga el llamaré F+. Una vez hallado F+
podré aplicar las formas normales de la teoría de la normalización.
Dado un conjunto F de dependencias funcionales se dice que f deriva de F (F├ f) si f se obtiene a partir de F.
Se define Cierre (F+) como el conjunto de todas las dependencias funcionales implicadas por F o halladas a
partir de F.
a) Axiomas
b) Propiedades propiamente dichas
a) Axiomas
CODPOSTAL ® CODPROV
a.2) Aumentatividad
Si X ® Y y Z c W => XW ® YZ
Si X ® Y y Y ® Z => X ® Z
b.1) Unión
X ® Y y X ® Z => X ® YZ
Demostración:
X ® Y y WY ® Z => WX ® Z
Demostración:
b.3) Descomposición
X ® Y y Z c Y => X ® Z
Demostración:
El conjunto de atributos Y tiene dependencia funcional total con X si Y tiene dependencia funcional con X (X ®
Y) y además no existe ningún subconjunto Z de X (Z c X) con el cual Y tenga dependencia funcional (Z ─/® Y).
Son una herramienta que sirve para tener una visión general de los datos y de las dependencias funcionales
entre ellos. S e representa en forma de grafo con los implicantes de las dependencias funcionales en un
rectángulo, de los que salen flechas hacia los implicados.
A C AB ® C
B B®C
SUPERCLAVE Y CLAVE
Superclave (SK): es el atributo o conjunto de atributos tales que en una relación R(A, DF) se cumple que SK ®
A. SK es el implicante capaz de implicar a la tabla completa.
W®X
W®Y
W®Z
Clave (K): es el atributo o conjunto de atributos tales que en una relación R(A, DF) es superclave y además no
existe ningún subconjunto K' c K tal que K' ® A
Debe tener una dependencia funcional total con los atributos de la tabla. Si tenemos:
WZ ® A
WZ ® B
WZ ® C
pero
Z ─/® A
Z ─/® B
Z ─/® C
2ª forma normal: se dice que una relación está en 2ª forma normal si cumple las siguientes condiciones:
Ej: AB ® C
B®D
A C
B D
D depende funcionalmente de B sólo y debería depender de AB para estar en 2ª forma normal. Para
convertirlo en 2ª forma normal se descompone en 2 tablas:
A
C B D
B
DNI NOMBRE
EMPLEADO SUELDO
DNI
SUELDO DNI NOMBRE
EMPLEADO
A ® B
B ─/® A => A®C
B ® C
Gráficamente:
3ª forma normal: se dice que una tabla está en 3ª forma normal si está en 2ª forma normal y además cumple
que ningún atributo no principal depende transitivamente de la clave.
B
A C
D
E
B
A D
C
E
no está en 3ª forma normal porque existen atributos no principales que dependen transitivamente de la clave
de la relación.
B
A
C
D
C
E
Descomponemos en 2 tablas:
B
A
C
D
C
E
Ej: Pasar a 3ª forma normal las siguientes dependencias de la tabla alumnos:
Forma normal de Boyce-Codd: Trata de resolver los problemas que origina la 3ª forma normal. Se dice que
una relación R está en FNBC sí y sólo si todo determinante o todo implicante (conjunto de atributos a la
izquierda de la relación) es clave.
Ej:
A
C
B
AB ® C
C®B
AB ® B
Para pasar a FNBC una relación R en la cual existe una dependencia del tipo X ® Y siendo X un atributo no
principal y siendo Y un atributo principal, descomponemos R en 2 proyecciones:
Obtenemos:
C B
C_POSTAL ® CIUDAD
DIRECCION, CIUDAD ® C_POSTAL
C_POSTAL CIUDAD
DIRECCION
C_POSTAL
CIUDAD DIRECCION
C_POSTAL
Dependencia multivaluada:
Sean A y B dos subconjuntos distintos de atributos de una tabla T se dice que A tiene una dependencia
multivaluada con B ó que A multidetermina a B ó que B depende multivaluadamente de A (A ®® B) ai para
cada valor de A tenemos un conjunto, bien sea de valores de B que son independientes de los demás
atributos, o la relación.
1. A <= B
2. Independientemente del resto de atributos de A
Ej:
Los profesores de una facultad imparten varias asignaturas y una asignatura es impartida por varios
profesores.
Una asignatura tiene varios textos y un texto puede utilizarse en varias asignaturas,
independientemente del profesor que las imparte.
ANA DIGITALES T1
ANA DIGITALES T2
LUIS DIGITALES T1
LUIS DIGITALES T2
LUIS COMUNICACIONES T2
LUIS COMUNICACIONES T3
Asignatura ®® Profesor
Asignatura ®® Texto
Siempre que se dé una dependencia X ®® Y tiene que darse una dependencia X ®® A - (X U Y).
Para que se dé debe tener más de 2 atributos.
Profesor ®® Asignatura
4ª Forma Normal: Una tabla está en 4ªFN si está en 3ªFN y se cumple que las únicas dependencias
multivaluadas existentes son las existentes con los atributos secundarios.
Cuando no existen dependencias multivaluadas y la tabla está en 3ªFN para pasar a 4ªFN tendremos en
cuenta el teorema de FAGIN: "Una tabla T con los atributos A, B, C se puede descomponer sin pérdida de
información en 2 proyecciones: T1 con los atributos A y B y T2 con los atributos A y C, sólo si A multidetermina
a B y C (A ®® B / C).
Para pasar a 4ªFN si existe una dependencia multivaluada X ®® Y la dividimos en 2 tablas.
1. R1 (x, y)
2. R2 (A - y)
R1 (x, y)
R: x ®® y
R2 (A - y)
Ej:
Asignatura ®® Texto
Asignatura ®® Profesor
1. Asignatura ®® Texto, x
2. Asignatura ®® Profesor, y
R1 (Asignatura, Texto, x)
R2 (Asignatura, Profesor, y)
Dependencia de JOIN
Se dice que una relación T formada por los atributos A1, A2, ..., An tiene una dependencia con sus
proyecciones T1, T2, ..., Tn si T=T1 T2 T3 ... Tn
T A B C T1 A B T2 B C
a1 b1 c1 a1 b1 b1 c1
a2 b1 c1 a2 b1 b2 c1
a1 b2 c1 a1 b2 b1 c2
a1 b1 c2
T<> T1 T2
T1 T2 A B C
a1 b1 c1
a1 b1 c2
a2 b1 c1
a2 b1 c2
a1 b2 c1
T3 A C
a1 c1
a2 c1
a1 c2
T=T1 T2 T3
5ª Forma Normal: Se dice que una tabla está en 5ªFN si está en 4ªFN y además toda dependencia de JOIN
está implicada por las claves de la tabla. Las columnas de enlace deben ser los atributos que componen la
clave.
Dependencias de JOIN:
T=T1 T2 T3
Los tres atributos forman la clave. T no está en 5ª forma normal. Si las columnas de enlace son las columnas
de la clave entonces está en 5ª forma normal. Para pasarlo a 5ª forma normal habrá que descomponer T en
sus proyecciones.
EMPLEADO = T1 t2 t3
Ej: Competiciones
Atributos:
Atributos:
1. SQL autocontenido
2. SQL embedido
SQL embedido:
Sentencia de SQL que se utiliza dentro de un programa llamado anfitrión, escrito en cualquier lenguaje.
Tendremos tablas con datos de entrada y de salida.
Las sentencias de SQL serán sentencias embedidas en el programa anfitrión.
Características:
EXEC SQL
<sentencias>
END-EXEC
* Antes de utilizar un compilador para manejar SQL embedido es necesario pasar el programa fuente por un
precompilador:
Ej: Para un vuelo, visualizar plazas libres y nº de vuelo (datos de salida), sabiendo el origen, destino, hora de
salida y fecha de salida (datos de entrada).
INICIO
escribir 'Introducir ORIGEN, DESTINO, FECHA, HORA'
leer ORIGEN, DESTINO, FECHA, HORA
EXEC SQL
SELECT RESERVAS.NUM_VUELO, PLAZAS_LIBRES
INTO :VUELO, :PLAZAS
FROM RESERVAS, VUELOS
WHERE RESERVAS.NUM_VUELO=VUELOS.NUM_VUELO
AND ORIGEN=:ORIGEN
AND DESTINO=:DESTINO
AND FECHA=:FECHA
AND HORA=:HORA
END-EXEC
escribir VUELO, PLAZAS
FIN
Cursor:
Es una estructura de datos tabular (en forma de tabla) que sirve para almacenar un número indeterminado
de filas.
Sólo permite manejar una única fila a la vez, mediante un puntero.
Para manejar cursores en SQL embedido hay 4 etapas:
EXEC SQL
DECLARE
<nom_cursor> CURSOR
FOR
<sent_select>
END-EXEC
2) Abrir cursor
EXEC SQL
OPEN <nom_cursor>
END-EXEC
EXEC SQL
FETCH <nom_cursor> {avanza el puntero una posición}
INTO <lista_variables> {una sóla variable por columna}
END-EXEC
Cuando se hace un OPEN se rellena la estructura y el puntero se posiciona anterior a la primera fila. El primer
FETCH posiciona el cursor en la primera fila.
4) Cerrar cursor
EXEC SQL
CLOSE <nom_cursor> {liberando memoria}
END-EXEC
Ej: Realizar un programa que presente todos aquellos vuelos existentes entre un origen y un destino
determinados.
Pasos:
1. Declaración de variables
2. Petición de información de origen y destino
3. Abrir cursor
4. Recuperar primera fila del cursor
5. Comprobar si existe alguna fila. Si no existe ir a 9
6. Escribir fila en pantalla
7. Recuperar siguiente fila
8. Ir a 5
9. Fin
VARIABLES
ORIGEN, DESTINO, HORA, VUELO: STRING
EXEC SQL
DECLARE lista_vuelos CURSOR
FOR SELECT NUM_VUELO, HORA_SALIDA
FROM VUELOS
WHERE ORIGEN=:ORIGEN
AND DESTINO=:DESTINO
END-EXEC
INICIO
ESCRIBIR 'INTRODUZCA ORIGEN Y DESTINO'
LEER ORIGEN, DESTINO
EXEC SQL
OPEN lista_vuelos
END-EXEC
EXEC SQL
FETCH lista_vuelos
INTO :VUELO, :HORA
END-EXEC
{Variable predefinida SQL-CODE: nos da información sobre la ejecución de cada sentencia en SQL:
SQL-CODE < 0 ® Error
SQL-CODE = 100 ® CURSOR vacío
SQL-CODE > 0 ® Warning}
1. Introducción
2. Integridad referencial
2.1 DDL
2.2 DML
3. Disparadores
4. Reglas semánticas
1. INTRODUCCION
Existen ciertas operaciones de SQL que pueden hacer peligrar la integridad de la operación:
- Inserción
- Borrado
- Modificación
depende
cod_fam
T.HIJA FAMILIARES DNI_EMP Clave Ajena
Tipos de integridad:
Integridad de dominio: restringimos los valores que puede tomar un atributo respecto a su dominio, por ejemplo
EDAD ® 18 - 65.
Integridad de entidad: la clave primaria de una entidad no puede tener valores nulos y siempre deberá ser
única, por ejemplo DNI.
Integridad referencial: las claves ajenas de una tabla hija se tienen que corresponder con la clave primaria de
la tabla padre con la que se relaciona. Por ejemplo, en familiares necesitaremos el DNI de empleado, que es la
clave ajena de la tabla.
2. INTEGRIDAD REFERENCIAL
2.1 DDL
2.2 DML
2.2.1 Inserción
2.2.2 Actualización
2.2.3 Borrado
Tabla padre: no se puede modificar el valor de clave primaria de la tabla padre si existe alguna fila en la tabla
hija que lo referencie en la clave ajena.
nommbre, cantidad
SELECT v.vennom, vn.cantidad as total FROM vendedor v, ventas vn, producto p where
p.procod=vn.procod AND vn.vencod=v.vencod
Total de ventas
SELECT vendedor.vennom, sum(ventas.cantidad*producto.propvp) WHERE vendedor.vencod =
ventas.vencod FROM ventas, vendedor GROUP BY vendedor.vennom
SELECT p.pronom, vn.cantidad FROM ventas vn, producto p WHERE vn.cantidad between 2 AND
5 AND p.procod=vn.procod
Esta regla se especifica al crear la tabla padre y se activará cuando se intente eliminar una fila de la tabla.
CREATE TABLE
...
FOREIGN KEY
...
RESTRICT
ON DELETE CASCADE
SET NULL
Es una regla explícita, ya que el usuario puede elegir la regla de borrado que desee, a partir de 3 reglas que
nos va a proporcionar el sistema.
a) RESTRICT
No se puede borrar una fila de la tabla padre si existen filas en la tabla hija cuyos valores de clave
ajena sean iguales a valores de clave primaria de la fila que queremos borrar.
b) CASCADE
Cada vez que se borre una fila de la tabla padre se eliminarán aquellas filas de la tabla hija que
tengan como valor de clave ajena el mismo valor que el de la clave primaria de la fila que se quiere borrar.
c) SET NULL
Cada vez que se elimine una fila de la tabla padre se actualizarán los campos de la clave ajena de la
tabla hija a valores nulos para aquellas filas que tengan en el campo de la clave ajena el mismo valor que la
clave primaria de la fila de la tabla padre que se quiere borrar.
Integridad auto-referencial
Todos los valores que aparezcan en la última columna existirán también en la primera, por tanto
COD_EMP_JEFE se convierte en clave ajena de la tabla.
Conjunto de tablas que funcionará como tablas padres e hijas unas de otras, formando un camino cerrado.
COCHES
DIRECTORES SECRETARIAS
Por haber ciclos debemos incorporar restricciones de borrado, para un correcto funcionamiento de la integridad
referencial.
Restricciones de borrado
a) Integridad auto-referencial
Siempre que tengamos una tabla con integridad auto-referencial debemos definir un borrado en
cascada.
Tabla EMPLEADO
COD_EMP COD_EMP_JEFE
A00 -
B01 A00
C02 B01
D03 C02
Con RESTRICT no se puede borrar la 3ª fila, porque C02, clave primaria, está siendo referenciada en la fila 4ª
como clave ajena. Salta a la 4 fila y la borra.
Con SET NULL borraría la primera fila, porque su clave ajena es NULL, pasaría a la 2ª y como su clave ajena
es igual a la clave primaria de la fila borrada pondría la clave ajena a NULL. Como le hemos dicho que borre
aquellas filas que tengan por clave ajena un valor nulo, ahora borraría esta fila y así sucesivamente hasta
eliminar la tabla completa.
DELETE FROM T3
WHERE FKT2 IS NULL
CICLO DE 2 TABLAS: ninguna de ellas podrá tener definida la opción de borrado en cascada.
CICLO DE MAS DE 2 TABLAS: Sólo una de las tablas podrá tener la opción de borrado en cascada.
El esquema anterior no cumple las restricciones expuestas.
c) Tablas conectadas por múltiples caminos (con más de una tabla padre)
DELETE FROM T2
WHERE PKT2 = 'T2A'
Los dos caminos que llegan a una tablas deben tener definida siempre la misma regla de borrado, que debe
ser RESTRICT o CASCADE.
En el ejemplo funcionaría bien por el primer camino, pero por el segundo hay restrinción.
Ej. propuesto: Pruébese que ocurriría si entre T3 y T1 hay SET NULL y entre T2 y T1 hay SET NULL.
Ventajas del uso de las reglas de integridad referencial proporcionadas por el sistema frente a la
implementación de estas por parte del usuario.
1. Al usar las proporcionadas por el sistema los analistas tienen menor responsabilidad.
3. La información será más coherente, ya que está garantizado que todas las filas de las tablas cumplen las
normas de integridad referencial.
3. DISPARADORES O 'TRIGGERS'
Son un conjunto de sentencias que el sistema ejecuta a la hora de efectuar una inserción,
actualización o borrado en una tabla. Para definir un TRIGGER necesitamos:
DB2 no incorpora la posibilidad de definir triggers, pero SQL sí. Las reglas de integridad referencial se
emulan en SQL mediante la implementación de triggers.
Según la regla de integridad referencial, no se puede efectuar una inserción en una tabla hija a menos que
exista un valor de clave primaria igual al de clave ajena de la fila que se desea insertar.
El trigger comparará el valor de clave ajena de la fila a insertar con el valor de clave primaria de la tabla hija
cada vez que se intente insertar una fila.
El explain plan, es un utilitario del manejador, el permite ver cual es el camino de búsqueda de la
información , que utiliza una instrucción SQL. A su vez nos indica si esta usando los índices.
Forma de uso:
- Crear las tablas de Explain Plan en la cuenta de usuario ORACLE a la cual se accesan las tablas.
@?/rdbms/admin/xplainpl
- Una vez creadas las tablas, se pueden correr los query sql o selección de datos, de la siguiente
forma en SQL*Plus:
Explain plan set statement_id = 'identificación' for 'el query SQL o instrucciones;
- Una vez corrido el query, el no arroja filas; indica que la operación termino. A continuación se
desea ver el camino o ruta recorrido por la instrucción, para lo cual se corre el siguiente Script
SQL.
El resultado, mostrara la ruta que siguen el manejador ORACLE para extraer los datos. Su
interpretación y mayor información referirse al Manual Oracle Rdbms Performance Tuning Guide.
NOTA: Luego de cada corrida del Explain Plan, el inserta información en la tabla de plan_table,
por lo que se recomienda eliminar los registros creados.