UNidad 3 para Gestion de Datos

UNIVERSIDAD TECNOLGICA NACIONAL
FACULTAD REGIONAL RESISTENCIA
INGENIERA EN SISTEMAS
DE INFORMACIN
GESTIN DE DATOS
APUNTES TERICOS
Unidad 6: SQL
Profesor Teora: Ing. Carolina Orcola
Jefe de T. P.: Ing. Luis Eiman
Auxiliar de T.P.: Juan Carlos Fernandez
Universidad Tecnolgica Nacional

Facultad Regional Resistencia
Ingeniera en Sistemas de Informacin

GESTIN DE DATOS
ndice
Unidad VI: SQL ............................................................................................................................... 3
Introduccin ................................................................................................................................ 3
Formas de las consultas SQL Bsicas ........................................................................................ 4
Ejemplos de consultas bsicas de SQL................................................................................... 7
Expresiones y cadenas de caracteres en la orden SELECT..................................................... 8
Subconsultas o Consultas Anidadas ........................................................................................... 9
Otros predicados ......................................................................................................................... 9
UNION, INTERSECT y EXCEPT .............................................................................................. 11
Consultas Anidadas .................................................................................................................. 15
Consultas anidadas correlacionadas ..................................................................................... 15
Ms ejemplos de consultas anidadas .................................................................................... 16
Operadores de agregacin........................................................................................................ 17
Ordenacin de datos resultantes............................................................................................... 19
La clusula GROUP BY y HAVING ............................................................................................. 19
Ms ejemplos de consultas de agregacin ............................................................................ 20
Valores nulos ............................................................................................................................ 22
Comparaciones que emplean valores nulos .......................................................................... 22
Las conectivas lgicas AND, OR y NOT................................................................................ 22
Consecuencias para las estructuras de SQL ......................................................................... 23
Reuniones externas .............................................................................................................. 23
Desactivacin de valores nulos ............................................................................................. 23
JOINs o Reuniones ................................................................................................................... 24
Reunin interna - clusulas inner join / on ............................................................................. 24
Reunin externa - left outer join / right outer join ................................................................... 24
Que trae de nuevo SQL Server 2008? ....................................... Error! Marcador no definido.
Bibliografa .................................................................................................................................... 26
Ing. Carolina Orcola
Ao 2010
Pgina 2


GESTIN DE DATOS
Unidad VI: SQL

El Lenguaje Estructurado de Consultas (Structured Query Lenguage, SQL) es el lenguaje
comercial de base de datos relacionales ms utilizado.
Los orgenes del SQL estn ligados a los de las bases de datos relacionales. En 1970 E. F. Codd
propone el modelo relacional y asociado a ste un sublenguaje de acceso a los datos basado en
el clculo de predicados. Basndose en estas ideas, los laboratorios de IBM definen el lenguaje
SEQUEL (Structured English QUEry Language) que ms tarde sera ampliamente implementado
por el SGBD (Sistemas Gestores de Bases de Datos) experimental System R, desarrollado en
1977 tambin por IBM. Sin embargo, fue Oracle quien lo introdujo por primera vez en 1979 en un
programa comercial.
El SEQUEL terminara siendo el predecesor de SQL, siendo ste una versin evolucionada del
primero. El SQL pasa a ser el lenguaje por excelencia de los diversos SGBD relacionales surgidos
en los aos siguientes y es por fin estandarizado en 1986 por el ANSI, dando lugar a la primera
versin estndar de este lenguaje, el "SQL-86" o "SQL1". Al ao siguiente este estndar es
tambin adoptado por la ISO.
Sin embargo, este primer estndar no cubre todas las necesidades de los desarrolladores e
incluye funcionalidades de definicin de almacenamiento que se consideraron suprimir. As que en
1992 se lanza un nuevo estndar ampliado y revisado del SQL llamado "SQL-92" o "SQL2".
En la actualidad el SQL es el estndar de facto de la inmensa mayora de los SGBD comerciales.
Y, aunque la diversidad de aadidos particulares que incluyen las distintas implementaciones
comerciales del lenguaje es amplia, el soporte al estndar SQL-92 es general y muy amplio.
El ANSI SQL sufri varias revisiones y agregados a lo largo del tiempo:
Ao Nombre
Alias
1986 SQL-86
SQL-87
1989 SQL-89
1992 SQL-92
SQL2
1999 SQL:1999 SQL2000
2003 SQL:2003
2006 SQL:2006
2008 SQL:2008
Comentarios
Primera publicacin hecha por ANSI. Confirmada por ISO en 1987.
Revisin menor.
Revisin mayor.
Se agregaron expresiones regulares, consultas recursivas (para relaciones
jerrquicas), triggers y algunas caractersticas orientadas a objetos.
Introduce algunas caractersticas de XML, cambios en las funciones,
estandarizacin del objeto sequence y de las columnas autonumericas. (Ver
Eisenberg et al.: SQL:2003 Has Been Published.)
ISO/IEC 9075-14:2006 Define las maneras en las cuales el SQL se puede utilizar
conjuntamente con XML. Define maneras importar y guardar datos XML en una
base de datos SQL, manipulndolos dentro de la base de datos y publicando el
XML y los datos SQL convencionales en forma XML. Adems, proporciona
facilidades que permiten a las aplicaciones integrar dentro de su cdigo SQL el uso
de XQuery, lenguaje de consulta XML publicado por el W3C (World Wide Web
Consortium) para acceso concurrente a datos ordinarios SQL y documentos XML.
Permite el uso de la clusula ORDER BY fuera de las definiciones de los cursores.
Incluye los disparadores del tipo INSTEAD OF. Aade la sentencia TRUNCATE.
Introduccin
El lenguaje SQL tiene varios aspectos diferentes:
Lenguaje de Manipulacin de Datos (LMD). Este subconjunto de SQL permite a los

usuarios formular consultas e insertar, eliminar y modificar filas.
Lenguaje de Definicin de Datos (LDD). Este subconjunto de SQL soporta la creacin,

eliminacin y modificacin de definiciones de tablas y vistas. Se pueden definir
restricciones de integridad para las tablas, ya sea en el momento de crearlas o
posteriormente.
Disparadores y restricciones de integridad avanzadas. Las normas de SQL:1999 ya

incluyen soporte para los disparadores (Triggers), que son acciones ejecutadas por el
SGBD siempre que las modificaciones de la base de datos cumplen las condiciones
especificadas en el disparador.
Ao 2010
Pgina 3


GESTIN DE DATOS
SQL incorporado y SQL dinmico. Las caractersticas de SQL incorporado permiten

llamar al cdigo SQL desde lenguajes anfitriones como C o Cobol.
Ejecucin cliente-servidor y acceso a bases de datos remotas. Estas rdenes

controlan el modo en que los programas de aplicacin cliente pueden conectarse con los
servidores de la base de datos de SQL o tener acceso a los datos de la base de datos a
travs de la red.
Gestin de transacciones. Diversas rdenes permiten que los usuarios controlen de

manera explcita aspectos del modo en que se deben ejecutar las transacciones.
Seguridad. SQL ofrece mecanismos para controlar el acceso de los usuarios a los objetos
de datos, como tablas y vistas.
Caractersticas avanzadas. Las normas SQL:1999 incluyen caractersticas orientadas a

objetos, consultas de apoyo a decisiones, y tambin aborda reas emergentes como la
minera de datos, datos espaciales y gestin de datos de texto y XML.
Las consultas que se van a usar de ejemplo emplean las tablas ya usadas en la unidad anterior,
es decir:
Marineros (idm: integer, nombrem: string, categoria: integer, edad: real)
Barcos (idb: integer, nombreb: string, color: string)
Reservas (idm: integer, idb: integer, fecha: date)
Se usan los ejemplares M3 y R2 de Marineros y Reservas respectivamente.
M3
idm
22
29
31
32
58
64
71
74
85
95
B1
nombrem
Dominguez
Barvo
Lorca
Alndez
Rubio
Horacio
Zuazo
Horacio
Arturo
Benito
idb
101
102
103
104
nombreb
Intrpido
Intrpido
Campen
Mstico
categoria
7
1
8
8
10
7
10
9
3
3
edad
45,0
33,0
55,5
25,5
35,0
35,0
16,0
35,0
25,5
63,5
R2
idm
22
22
22
22
31
31
31
64
64
74
idb
101
102
103
104
102
103
104
101
102
103
fecha
10/10/2008
10/10/2008
10/8/2008
10/7/2008
11/10/2008
11/6/2008
11/12/2008
9/5/2008
9/8/2008
9/8/2008
color
azul
rojo
verde
rojo
Formas de las consultas SQL Bsicas

La forma bsica de las consultas de SQL son:
SELECT [DISTINCT] lista-de-seleccin

FROM lista-de-tablas
WHERE condicin
Todas las consultas deben tener una clusula SELECT, que especifica las columnas que se
deben conservar en el resultado, y una clusula FROM, que especifica un producto cartesiano de
las tablas que all se enuncian. La clusula opcional WHERE especifica las condiciones de
seleccin para las tablas indicadas en FROM.
Una consulta as, intuitivamente, corresponde a una expresin del lgebra relacional que implica
selecciones, proyecciones y productos cartesianos. La estrecha relacin entre SQL y el lgebra
Ao 2010
Pgina 4


GESTIN DE DATOS
relacional es la base de la optimizacin de las consultas en los SGBD relacionales. En realidad,

los planes de ejecucin de las consultas SQL se presentan mediante una variacin de las
expresiones del lgebra relacional.
Consideremos ejemplos sencillos para comprender mejor las consultas:
(C15) Averiguar el nombre y la edad de todos los marineros.
SELECT DISTINCT M.nombrem, M.edad
FROM Marineros M
La respuesta es un conjunto de filas, cada una de ellas es un par (nombrem, edad). Si dos o ms
marineros tienen el mismo nombre y la misma edad, la respuesta sigue teniendo una sola pareja
con ese nombre y esa edad. Esta consulta es equivalente a la aplicacin del operador proyeccin
del lgebra relacional.
Si se omite la palabra clave DISTINCT, se obtendr una copia de la fila (n,e) por cada marinero
de nombre n y edad e; la respuesta sera un multiconjunto de filas. Los multiconjuntos se parecen
a los conjuntos en que son colecciones desordenadas de elementos, pero en los multiconjuntos
puede haber varias copias de cada elemento y el nmero de copias es significativo dos
multiconjuntos pueden tener los mismos elementos y ser diferentes porque el nmero de copias
de algn elemento sea diferente-. Por ejemplo, {a,b,b} y {b,a,b} denotan el mismo multiconjunto, y
son diferentes del multiconjunto {a,a,b}.
La respuesta a esta consulta, con o sin la palabra DISTINCT, para el ejemplar M3 de Marinero
se puede ver en las figuras siguientes. La nica diferencia es que la tupla de Horacio aparece dos
veces si se omite DISTINCT, esto se debe a que hay dos marineros que se llaman Horacio y
tienen 35 aos.
nombrem
Dominguez
Barvo
Lorca
Alndez
Rubio
Horacio
Zuazo
Horacio
Arturo
Benito
nombrem
Dominguez
Barvo
Lorca
Alndez
Rubio
Horacio
Zuazo
Arturo
Benito
edad
45,0
33,0
55,5
25,5
35,0
35,0
16,0
35,0
25,5
63,5
Respuesta a C15 sin DISTINCT
edad
45,0
33,0
55,5
25,5
35,0
35,0
16,0
25,5
63,5
Respuesta a C15
La siguiente consulta es equivalente a una aplicacin del operador seleccin del lgebra
relacional.
(C11) Averiguar todos los marineros con categora superior a 7.
{ M | M Marineros M.categoria > 7} En Clculo Relacional de Tuplas
SELECT M.idm, M.nombrem, M.categora, M.edad

FROM Marineros AS M
WHERE M.categora > 7
Esta consulta emplea la palabra clave opcional AS para introducir una variable de rango. Cuando,
como en este caso, se desea recuperar todas las columnas de una tabla, SQL ofrece la alternativa
de abreviar la consulta escribiendo directamente SELECT *. Esta notacin resulta til para las
consultas interactivas, pero no es una buena prctica para las consultas que se pretende volver a
utilizar y conservar, ya que el esquema del resultado no queda claro desde la propia consulta; hay
que hacer referencia al propio esquema de la tabla Marineros subyacente.
La clusula SELECT se emplea realmente para hacer proyecciones, mientras que las selecciones
en el sentido del lgebra relacional se expresan mediante la clusula WHERE. Este desajuste entre
la denominacin de los operadores seleccin y proyeccin del lgebra relacional y la sintaxis de
SQL es un accidente histrico desafortunado.
Ao 2010
Pgina 5


GESTIN DE DATOS
Veamos la sintaxis de las consultas e SQL con mayor detalle:
La lista-de-tablas de la clusula FROM es una lista de nombres de tablas. El nombre de

cada tabla puede ir seguido de una variable de rango; las variables de rango resultan
especialmente tiles cuando el mismo nombre de tabla aparece ms de una vez en esta
lista.
La lista-de-seleccin es una lista de (expresiones que implican a) nombres de columna de

tabla que se mencionan en la lista-de-seleccin. A los nombres de columna se le pueden
anteponer una variable de rango.
La condicin de la clusula WHERE es una combinacin booleana (es decir, una

expresin que emplea las conectivas lgicas AND, OR y NOT) de condiciones de la forma
expresin op expresin, donde op es alguno de los operadores de comparacin {<, <=, =,
<>, >=, >}. Una expresin es un nombre de columna, una constante o una expresin
(aritmtica o cadena de caracteres).
La palabra clave DISTINCT es opcional. Indica que la tabla calculada como respuesta a
la consulta no debe contener duplicados, es decir, dos copias de la misma fila. El valor
predeterminado es que los duplicados no se eliminan.
Aunque las reglas anteriores describen (de manera informal) la sintaxis de las consultas bsicas
de SQL, no indican el significado de las consultas. La respuesta de las consultas es en si misma
una relacin que es un multiconjunto de filas en SQL_ cuyo contenido se puede comprender
considerando la siguiente estrategia de evaluacin conceptual:
1. Calcular el producto cartesiano de las tablas de la lista-de-tablas.
2. Eliminar filas del producto cartesiano que no cumplan las condiciones de condicin.
3. Eliminar todas las columnas que no aparezcan en la lista-de-seleccin.
4. Si se especifica DISTINCT, eliminar las filas repetidas.
Esta sencilla estrategia de evaluacin conceptual explicita las filas que deben encontrarse en la
respuesta a la consulta. Sin embargo, es probable que sean bastante ineficiente.
(C1) Averiguar el nombre de los marineros que han reservado el barco 103
En lgebra relacional era:
idb=103 ( nombrem (Reservas Marineros) )
En SQL es:
SELECT M.nombrem
FROM Marineros M, Reservas R
WHERE M.ide = R.ide AND R.ide = 103
Usamos para esta consulta los ejemplares R3 de reservas y M4 de Marineros (para hacer menos
tedioso el ejemplo).
M4 idm
nombrem
categoria
edad
R3 Idm
idb
fecha
22 Dominguez
7
45,0
22
101
10/10/2008
31 Lorca
8
55,5
58
103
11/12/2008
58 Rubio
10
35,0
El primer paso es crear el producto cartesiano de M4XR3, que podemos ver en la siguiente figura.
idm
22
22
31
31
58
58
nombrem
Dominguez
Dominguez
Lorca
Lorca
Rubio
Rubio
categoria
7
7
8
8
10
10
Ao 2010
edad
45,0
45,0
55,5
55,5
35,0
35,0
Idm
22
58
22
58
22
58
idb
101
103
101
103
101
103
fecha
10/10/2008
11/12/2008
10/10/2008
11/12/2008
10/10/2008
11/12/2008
Pgina 6


GESTIN DE DATOS
El segundo paso es aplicar la condicin M.ide = R.ide AND R.ide = 103. Este paso elimina todas
las filas del ejemplar resultante del producto cartesiano visto antes menos la ltima.
idm
58
Nombrem
Rubio
categoria
10
edad
35,0
Idm
58
idb
103
fecha
11/12/2008
El tercer paso es eliminar las columnas no deseadas; solo aparece nombrem en la clusula
SELECT. Este paso deja entonces una sola columna y una sola fila, que es la siguiente:
nombrem
Rubio
Ejemplos de consultas bsicas de SQL
A continuacin se presentan varios ejemplos de consultas SQL, muchas de las cuales ya se
expresaron anteriormente en el lgebra relacional y el clculo relacional. El primer ejemplo ilustra
que el empleo de variables de rango es opcional, a menos que sea necesario para resolver alguna
ambigedad. La consulta C1, que ya se vi antes, tambin se puede expresar de la siguiente
manera:
SELECT nombrem
WHERE M.ide = R.ide AND ide = 103
Slo hay que cualificar las apariciones de idm, ya que esta columna aparece en las dos tablas
vinculadas a la consulta. Otra manera equivalente de escribir esta consulta sera:
SELECT nombrem
FROM Marineros, Reservas
WHERE Marineros.ide = Reservas.ide AND R.ide = 103
Esta consulta muestra que los nombres de las tablas se pueden emplear de manera implcita
como variables de fila. Slo hace falta introducir variables de rango de manera explcita cuando la
clusula FROM contiene ms de una aparicin de una misma relacin. No obstante, se
recomienda el empleo explcito de las variables de rengo y la condicin completa de todas las
apariciones de las columnas con una variable de rango para mejorar la legibilidad de las
consultas.
(C16) Averiguar el idm de los marineros que han reservado barcos rojos.
SELECT R.idm
FROM Barcos B, Reservas R
WHERE B.idb = R.idb AND B.color = rojo
Esta consulta contiene una reunin de dos tablas, seguida de una seleccin del color de los
barcos. Se puede pensar en B y en R como en filas de las tablas correspondientes que prueban
que un marinero con idm = R.idm reserv un barco B.idb rojo.
(C2) Averiguar el nombre de los marineros que han reservado barcos rojos.
En lgebra relacional:
nombrem (color=rojo (Barcos) Reservas Marineros)

En SQL:
SELECT M.nombrem
FROM Marineros M, Reservas R, Barcos B
WHERE M.idm = R.idm AND R.idb = B.idb AND B.color = rojo
Esta consulta contiene una reunin de tres tablas seguida de una seleccin del color de los
barcos. La reunin con Marineros permite averiguar el nombre del marinero que, segn la tupla R
de Reservas, ha reservado el barco rojo descripto por la tupla B.
Ao 2010
Pgina 7


GESTIN DE DATOS
(C3) Averiguar el color de los barcos reservados por Lpez.

color (nombrem=Lpez (Marineros) Reservas Barcos)

En SQL:
SELECT B.color
WHERE M.idm = R.idm AND R.idb = B.idb AND M.nombre = Lpez
Esta consulta es muy parecida a la anterior. Obsrvese que, en general, puede que haya ms de
un marinero llamado Lpez (ya que nombrem no es clave de Marineros); esta consulta sigue
siendo correcta en el sentido que devolver el color de los barcos reservados por algn Lpez, si
es que hay varios marineros llamados Lpez.
(C4) Averiguar el nombre de los marineros que han reservado, como mnimo, un barco.
nombrem (Marineros Reservas)

En SQL:
SELECT M.nombrem
WHERE M.idm = R.idm
La reunin de Marineros y Reservas garantiza que, para cada nombrem seleccionado, el marinero
haya hecho alguna reserva. (Si algn marinero no ha hecho ninguna reserva, el segundo paso de
la estrategia de evaluacin conceptual eliminar todas las filas del producto cartesiano que
impliquen a ese marinero).
Expresiones y cadenas de caracteres en la orden SELECT
SQL soporta una versin ms general de la lista-de-seleccin que una mera lista de columnas.
Cada elemento de una lista-de-seleccin puede ser de la forma expresin AS nombre-columna,
donde expresin es cualquier expresin aritmtica o de cadena de caracteres para los nombres de
las columnas (posiblemente con variables de rango antepuestas) y constantes, y nombre-columna
es un nombre nuevo para esa columna en el resultado de la consulta.
Tambin puede contener agregados como sum y count, entre otros. La norma de SQL tambin
incluye expresiones para los valores de fecha y de hora, que no se tratarn. Aunque no forman
parte de la norma de SQL, muchas implementaciones soportan tambin el empleo de funciones
predefinidas como sqrt, sen y mod.
(C17) Calcular el incremento de la categora de las personas que han navegado en dos barcos
diferentes el mismo da.
SELECT M.nombrem, M.categora+1 AS categora

FROM Marineros M, Reservas R1, Reservas R2
WHERE M.idm = R1.idm AND M.idm = R2.idm AND R1.fecha = R2.fecha
AND R1.idb <> R2.idb
Adems, cada elemento de la condicin puede ser tan general como expresin1 = expresin2.
SELECT M1.nombrem AS nombre1, M2.nombrem AS nombre2

FROM Marineros M1, Marineros M2
WHERE 2*M1.categora = M2.categora-1
Para la comparacin de cadenas de caracteres se pueden emplear las operaciones de
comparacin (=, <, >, etc.) con el orden de la cadena de caracteres determinado alfabticamente,
como de costumbre. Si hay que ordenar las cadenas de caracteres de manera diferente a la
alfabtica (por ejemplo, ordenar las cadenas de caracteres que denotan el nombre de los meses
segn su orden en el calendario enero, febrero, marzo, etc.), SQL soporta el concepto general de
Ao 2010
Pgina 8


GESTIN DE DATOS
ordenacin, u orden de colocacin, para los conjuntos de caracteres. La ordenacin permite que
el usuario especifique los caracteres que son menores que otros y ofrece gran flexibilidad para la
manipulacin de cadenas de caracteres.
Adems, SQL ofrece soporte para la comparacin de estructuras mediante el operador LIKE,
junto con el uso de los smbolos % (que sustituye a cero o ms caracteres arbitrarios) y _ (que
sustituye exactamente a un carcter arbitrario). As _AB% denota una estructura que coincida
con todas las cadenas de caracteres que contienen, como mnimo, tres caracteres, en las que el
segundo y tercer carcter son A y B respectivamente. Observemos que, a diferencia de los dems
operadores de comparacin, los espacios en blanco pueden resultar significativos para el
operador LIKE (dependiendo de la ordenacin del conjunto de caracteres subyacentes). Por lo
tanto, Jess=Jess es verdadero, mientras que Jess LIKE Jess es falso. Veamos un
ejemplo de LIKE.
(C18) Averiguar la edad de los marineros cuyo nombre comienza con B, acaba con O y tiene
como mnimo seis caracteres.
SELECT M.edad
FROM Marineros M
WHERE M.nombrem LIKE B_%_ _ _O
Subconsultas o Consultas Anidadas
Al escribir una consulta, a veces hay que expresar una condicin que hace referencia a alguna
tabla que, a su vez, se debe calcular. Las consultas empleadas para calcular esas tablas son
subconsultas y aparecen como parte de las consultas principales.
Una subconsulta es una consulta incluida en una clusula WHERE o HAVING(1) de otra consulta.
En algunas ocasiones, para expresar ciertas condiciones no hay ms remedio que obtener el valor
que buscamos como resultado de una consulta.
SELECT M.nombrem
FROM Marineros M
WHERE M.categoria = (SELECT MAX M.categoria
FROM Marineros M)
En este ejemplo, queremos ver los nombre de los marineros que tienen la categora mxima, y
para ello debemos primero averiguar cul es esa categora mxima (usamos la funcin de
agregacin MAX que veremos luego).
(1) La clusula HAVING la vemos despus.
Otros predicados
Predicado BETWEEN
Para expresar una condicin que quiere encontrar un valor entre unos lmites concretos podemos
usar el predicado BETWEEN.
SELECT columnas
FROM tabla
WHERE columna BETWEEN lmite1 AND lmite2
Por ejemplo, queremos ver los marineros cuyo rango de edad est entre 20 y 35 aos:
SELECT M.nombrem
FROM Marineros M
WHERE M.edad BETWEEN 20 AND 35
Ao 2010
Pgina 9


GESTIN DE DATOS
Predicado IN
Para comprobar si un elemento coincide con los elementos de una lista utilizaremos IN, y para
ver si no coinciden NOT IN.
SELECT columnas
FROM tabla
WHERE columna [NOT] IN (valor1 valorN)
Por ejemplo, queremos ver los marineros cuya edad sea 15, 20 y 30 aos:
SELECT M.nombrem
FROM Marineros M
WHERE M.edad IN (15, 20, 35)
Predicado IS
Para comprobar si un valor es nulo utilizamos IS NULL, y para averiguar si no es nulo, IS NOT
NULL. El formato es:
SELECT columnas
FROM tabla
WHERE columna IS [NOT] NULL
Como ejemplo, supongamos que la tabla Marineros tiene una columna ms hijos, en la que se
pone la cantidad de hijos que tiene. Bajo ese supuesto, se puede escribir la consulta pidiendo el
nombre de los marineros sin hijos, as:
SELECT M.nombrem
FROM Marineros M
WHERE M.hijos IS NULL
Predicado ALL o ANY/SOME
Para ver si una columna cumple con la condicin de que todas sus filas (ALL) o algunas de sus
filas (ANY/SOME) satisfaga una condicin, podemos escribir:
SELECT columnas
FROM tabla
WHERE columna operador_comparacin {ALL/ANY/SOME} subconsulta
Por ejemplo, escribimos una consulta que liste los idb de los barcos que fueron reservados por
marineros todos mayores de 18 aos:
SELECT R.idb
FROM Reserrvas R
WHERE R.idm = ALL SELECT M.idm
FROM Marineros M
WHERE M.edad>=18
Y para ejemplificar el uso de ANY/SOME, podemos pedir que liste los idb de los barcos que fueron
reservados por al menos un o algn marinero mayor de 18 aos:
SELECT R.idb
FROM Reserrvas R
WHERE R.idm = ANY SELECT M.idm
FROM Marineros M
WHERE M.edad>=18
Ao 2010
Pgina 10


GESTIN DE DATOS
Predicado EXIST
Para comprobar si una consulta produce alguna fila de resultado, es decir, si existe un resultado,
podemos usar el predicado EXISTS. As mismo, para comprobar si no existe se aplicara NOT
EXISTS.
SELECT columnas
FROM tabla
WHERE [NOT] EXISTS subconsulta
Por ejemplo, para mostrar el idm y nombre de los marineros que reservaron un bote determinado
podemos tambin escribir:
SELECT M.idm, M.nombrem

FROM Marineros M
WHERE EXISTS SELECT R.idm
FROM Reserrvas R
WHERE R.idb = 103
UNION, INTERSECT y EXCEPT
SQL ofrece tres estructuras para la manipulacin de conjuntos que ampla la forma bsica de las
consultas presentadas hasta aqu. Dado que la respuesta a cada consulta es un multiconjunto de
filas, resulta natural considerar el empleo de operaciones como la unin, la interseccin y la
diferencia de conjuntos. SQL soporta estas operaciones con los nombres de UNION,
INTERSECT y EXCEPT. SQL ofrece tambin aplicar otras operaciones con conjuntos, que
hemos visto antes, como: IN (para comprobar si un elemento pertenece a un conjunto dado), ANY
y ALL (para comparar un valor con los elementos de un conjunto dado) y EXIST (para comprobar
si un conjunto est vaco).
La clusula UNION puede unir dos o ms sentencias SELECT FROM. Su formato es:
SELECT columna
FROM tabla
[WHERE condiciones]
UNION [ALL]
SELECT columna
FROM tabla
[WHERE condiciones]
Si ponemos la opcin ALL, aparecern todas las filas obtenidas a causa de la unin. No la
pondremos si queremos eliminar las filas repetidas. Las tablas resultantes de las sentencias a unir
deben ser compatibles con la unin.
Consideremos la siguiente consulta:
(C5) Averiguar el nombre de los marineros que han reservado barcos rojos o verdes.
SELECT M.nombrem
WHERE M.idm=R.idm AND R.idb=B.idb
AND (B.color=rojo OR B.color=verde)
Esta consulta se expresa fcilmente usando el operador OR en la clusula WHERE. Sin embargo,
la siguiente consulta, que es idntica salvo por el empleo de y en lugar de o resulta mucho ms
difcil:
(C6) Averiguar el nombre de los marineros que han reservado barcos rojos y verdes.
Ao 2010
Pgina 11


GESTIN DE DATOS
Si simplemente se tuviera que sustituir el operador OR en la clusula WHERE por el de AND, en

analoga con la expresin escrita de las consultas, se recuperara el nombre de los marineros que
han reservado barcos que son a la vez rojos y verdes (no los que reservaron barcos rojos y barcos
verdes). La restriccin de integridad de que idb es clave de Barcos indica que el mismo barco no
puede tener dos colores y, por lo tanto, la variante de la consulta anterior dara siempre resultados
vacos. La respuesta correcta de la consulta C6 es la siguiente:
SELECT M.nombrem
FROM Marineros M, Reservas R1, Barcos B1, Reservas R2, Barcos B2
WHERE M.idm=R1.idm AND R1.idb=B1.idb
AND M.idm=R2.idm AND R2.idb=B2.idb
AND B1.color=rojo AND B2.color=verde
Se puede pesnar en R1 y en B1 como en filas que prueban que el mariner M.idm ha reservado
barcos rojos; y de manera parecida, R2 y B2 prueban que el mismo marinero ha reservado
tambin barcos verdes. M.nombrem no se incluye en el resultado a menos que se encuentren
cinco filas como M, R1, B1, R2 y B2.
La consulta anterior es difcil de comprender (y tambin ineficiente de ejecutar). Una solucin ms
adecuada para estas dos consultas sera emplear UNION e INTERSECT.
As, la consulta C5 se puede escribir:
SELECT M.nombrem
AND B.color=rojo
UNION
SELECT M2.nombrem
FROM Marineros M2, Reservas R2, Barcos B2
WHERE M2.idm=R2.idm AND R2.idb=B2.idb
AND B2.color=verde
Esta consulta indica que se desea la unin del conjunto de marineros que han reservado barcos
rojos con el conjunto de marineros que han reservado barcos verdes.
En completa simetra, la consulta C6 se escribira:
SELECT M.nombrem
AND B.color=rojo
INTERSECT
SELECT M2.nombrem
AND B2.color=verde
La clusula INTERSECT genera la interseccin entre dos o ms sentencias SELECT FROM. Su
formato es:
SELECT columna
FROM tabla
[WHERE condiciones]
INTERSECT [ALL]
SELECT columna
FROM tabla
Ao 2010
Pgina 12


GESTIN DE DATOS
[WHERE condiciones]
Si ponemos la opcin ALL, aparecern todas las filas obtenidas a partir de la interseccin. No la
pondremos si queremos eliminar las filas repetidas.
Las tablas resultantes de las sentencias a unir deben ser compatibles con la unin.
Interseccin utilizando IN
SELECT columna
FROM tabla
WHERE columna IN ( SELECT columna
FROM tabla
[WHERE condiciones])
Interseccin utilizando EXISTS
SELECT columna
FROM tabla
WHERE EXISTS (SELECT *
FROM tabla
WHERE condiciones)
Para hallar la diferencia entre dos o ms sentencias SELECT FROM podemos utilizar la clsula
EXCEPT, que tiene este formato:
SELECT columna
FROM tabla
[WHERE condiciones]
EXCEPT [ALL]
SELECT columna
FROM tabla
[WHERE condiciones]
Si ponemos la opcin ALL, aparecern todas las filas obtenidas a partir de la diferencia. No la
pondremos si queremos eliminar las filas repetidas.
Al igual que la interseccin y la unin, las relaciones que componen la diferencia deben ser
compatibles con la unin, o debemos forzar que las columnas a vincular lo sean.
La diferencia es, junto con la interseccin, una de las operaciones del SQL que se puede realizar
de ms formas diferentes. As es que podemos encontrar la diferencia usando en vez de EXCEPT
los predicados NOT IN o NOT EXIST, de la siguiente forma:
Interseccin utilizando NOT IN
SELECT columna
FROM tabla
WHERE columna NOT IN ( SELECT columna
FROM tabla
[WHERE condiciones])
Ao 2010
Pgina 13


GESTIN DE DATOS
Interseccin utilizando NOT EXISTS
SELECT columna
FROM tabla
WHERE NOT EXISTS (SELECT *
FROM tabla
WHERE condiciones)
La siguiente consulta ilustra la operacin diferencia de conjuntos en SQL:
(C19) Averiguar el idm de todos los marineros que han reservado barcos rojos pero no verdes.
SELECT M.idm
AND B.color=rojo
EXCEPT
SELECT M2.idm
AND B2.color=verde
Los marineros 22, 64 y 31 han reservado barcos rojos. Los marineros 22, 74 y 31 han reservado
barcos verdes. Por lo tanto, la respuesta contiene solo el idm 64.
En realidad, dado que la relacin Reservas contiene informacin sobre los idms, no hay necesidad
alguna de consultar a la relacin Marineros, y se puede simplificar la consulta de la siguiente
manera:
SELECT R.idm
FROM Reservas R, Barcos B
WHERE R.idb=B.idb AND B.color=rojo
EXCEPT
SELECT R2.idm
FROM Reservas R2, Barcos B2
WHERE R2.idb=B2.idb AND B2.color=verde
Obsrvese que esta consulta confa en la integridad referencial; es decir, no hay reservas de
marineros que no existan. Tengamos en cuenta que UNION, INTERSECT y EXCEPT se pueden
emplear en cualquier par de tablas compatibles con la unin, es decir, que tengan el mismo
nmero de columnas y esas columnas, tomadas en orden, se correspondan sus dominios. Por
ejemplo se puede escribir la siguiente consulta:
(C20) Averiguar el idm de los marineros que tengan una categora de 10 o hayan reservado el
barco 104.
SELECT M.idm
FROM Marineros M,
WHERE M.categora=10
UNION
SELECT R.idm
FROM Reservas R,
WHERE R.idb=104
Ao 2010
Pgina 14


GESTIN DE DATOS
La primer parte de la unin devuelve los idms 58 y 71. La segunda parte devuelve 22 y 31. La
respuesta es, por lo tanto, el conjunto de idms 22, 31, 58 y 71. Un ltimo punto a destacar sobre la
UNION, INTERSECT y EXCEPT es: a diferencia del criterio predeterminado de que de la forma
bsica de las consultas no se eliminan los duplicados a menos que se especifique DISTINCT, el
criterio predeterminado para las consultas UNION es que los duplicados s se eliminan, a menos
que escribamos UNION ALL, que fuerza a dejar los duplicados. Igual para el caso de
INTERSECT ALL o de EXCEPT ALL.
Consultas Anidadas
Volvamos a las subconsultas o consultas anidadas, dando ejemplos de su uso. A manera de
ejemplo reescribiremos la siguiente consulta empleando una subconsulta anidada:
SELECT M.nombrem
FROM Marineros M,
WHERE M.ide IN (SELECT R.idm
FROM Reservas R,
WHERE R.ide = 103)
La subconsulta anidada calcula el (multi)conjunto de idms de los marineros que han reservado el
barco 103 (el conjunto contiene 22, 31 y 74 para los ejemplares R2 y M3) y la consulta de nivel
superior recupera el nombre de los marineros cuyo idm se halla en ese conjunto. El operador IN,
como ya vismos antes, permite comprobar si un valor pertenece a un conjunto de elementos dado.
Veamos que para averiguar todos los marineros que NO reservaron el barco 103 bastara con
sustituir IN por NOT IN.
Veamos ahora un ejemplo de consulta con varios anidamientos:
(C2) Averiguar el nombre de los marineros que han reservado barcos rojos.
SELECT M.nombrem
FROM Marineros M,
WHERE M.idm IN ( SELECT R.idm
FROM Reservas R,
WHERE R.idb IN ( SELECT B.idb
FROM Barcos B,
WHERE B.color = rojo))
La subconsulta ms interna busca el conjunto de idbs de los barcos rojos (102 y 104 para el
ejemplar B1). La subconsulta que se halla un nivel por encima de ella busca el conjunto de idms
de los marineros que han reservado algunos de esos barcos. Para los ejemplares B1, R2 y M3
ese conjunto de idms contiene 22, 31 y 64. La consulta de nivel superior busca el nombre de los
marineros que pertenecen a ese conjunto de idms; y se obtiene Dominguez, Lorca y Horacio.
Para averiguar el nombre de los marineros que NO han reservado barcos rojos, se sustituye la
aparicin ms externa de IN por NOT IN, de la siguiente manera:
SELECT M.nombrem
FROM Marineros M,
WHERE M.idm NOT IN ( SELECT R.idm
FROM Reservas R,
WHERE R.idb IN ( SELECT B.idb
FROM Barcos B,
WHERE B.color = rojo))
Esta consulta calcula el nombre de los marineros cuyo idm no pertenece al conjunto 22, 31 y 64.
Consultas anidadas correlacionadas
En las consultas anidadas vistas hasta el momento la subconsulta interior ha sido completamente
independiente de la consulta exterior. En general la subconsulta interior puede depender de la fila
que se est examinando en cada momento en la consulta exterior (en trminos de la estrategia de
evaluacin conceptual). Reescribamos una vez ms la siguiente consulta:
Ao 2010
Pgina 15


GESTIN DE DATOS
SELECT M.nombrem
FROM Marineros M,
WHERE EXIST ( SELECT *
FROM Reservas R,
WHERE R.ide = 103 AND R.idm = M.idm)
El operador EXIST, como se vi antes, es otro operador para la comparacin de conjuntos, como
IN, permite comprobar si un conjunto no est vaco. Por lo tanto, para cada fila M de Marineros,
se comprueba si el conjunto de filas de Reservas R tal que R.ide = 103 AND R.idm = M.idm no
est vaco. Si no lo est, el marinero M ha reservado el barco 103 y se devuelve su nombre. La
subconsulta depende claramente de la fila actual M y se debe volver a evaluar para cada fila de
Marineros. La aparicin de M en la subconsulta se denomina correlacin, y estas consultas se
denominan consultas correlacionadas.
Esta consulta tambin ilustra el empleo del smbolo especial * en situaciones en las que todo lo
que se desea hacer es comprobar si existe una fila que cumpla la condicin y no se desea
realmente recuperar ninguna columna de esa fila.
Como ejemplo adicional, mediante el empleo de NOT EXIST en lugar de EXIST, se puede
calcular el nombre de los marineros que no han reservado barcos rojos. Estrechamente
relacionado con EXIST est el predicado UNIQUE. Cuando se aplica UNIQUE a una
subconsulta, la condicin resultante devuelve verdadero si ninguna fila aparece dos veces en la
respuesta de la subconsulta, es decir, si no hay ningn duplicado; en especial devuelve
verdadero si la respuesta est vaca.
Ms ejemplos de consultas anidadas
Veamos ms ejemplos de consultas anidadas:
(C6) Averiguar el nombre de los marineros que han reservado barcos rojos y verdes.
SELECT M.nombrem
FROM Marineros M, Reservas R, Barcos B,
WHERE M.idm=R.idm AND R.idb=B.idb AND B.color=rojo
AND M.idm IN ( SELECT M2.idm
FROM Marineros M2, Reservas R2, Barcos B2,
AND B2.color=verde)
Esta consulta se la puede entender de la siguiente manera: Averiguar todos los marineros que
han reservado barcos rojos y, adems, tienen idms que estn incluidos en el conjunto de idms de
marineros que han reservado barcos verdes. Esta formulacin de la consulta ilustra la manera en
la que las consultas que implican a INTERSECT se pueden reescribir usando IN, lo que es muy
til saber cuando el sistema no soporta INTERSECT. Las consultas que emplean EXCEPT se
pueden reescribir de manera parecida usando NOT IN. Para averiguar los idms de los marineros
que han reservado barcos rojos pero no barcos verdes basta con sustituir la palabra clave IN de
la consulta anterior por NOT IN.
SELECT M.nombrem
FROM Marineros M,
WHERE M.idm IN ( (SELECT R.idm
FROM Reservas R, Barcos B,
WHERE R.idb=B.idb AND B2.color=rojo)
INTERSECT
(SELECT R2.idm
FROM Reservas R2, Barcos B2,
WHERE R2.idb=B2.idb AND B2.color=verde) )
Ao 2010
Pgina 16


GESTIN DE DATOS
Como se puede ver en la consulta anterior, escribir la consulta (C6) empleando INTERSECT
resulta ms complicado porque hay que utilizar los idms para identificar a los marineros (durante
la interseccin) y hay que devolver el nombre de los marineros.
El siguiente ejemplo ilustra la manera que se puede expresar en SQL la operacin divisin del
lgebra relacional:
(C9) Averiguar el nombre de los marineros que han reservado todos los barcos.
SELECT M.nombrem
FROM Marineros M,
WHERE NOT EXIST ( (SELECT B.idb
FROM Barcos B,
EXCEPT
(SELECT R.idb
FROM Reservas R,
WHERE R.idm=M.idm) )
Obsrvese que esta consulta est correlacionada para cada miembro de M se comprueba si el
conjunto de barcos reservados por M incluye todos los barcos-. Una manera alternativa de llevar a
cabo la consulta sin emplear EXCEPT es la siguiente:
SELECT M.nombrem
FROM Marineros M,
WHERE NOT EXIST ( (SELECT B.idb
FROM Barcos B,
WHERE NOT EXIST (SELECT R.idb
FROM Reservas R,
WHERE R.idb=B.idb
AND R.idm=M.idm) )
De manera intuitiva, para cada marinero se comprueba que no hay ningn barco que no haya sido
reservado por ese marinero.
Operadores de agregacin
Adems de recuperar datos, a menudo se desea llevar a cabo algn clculo o resumen en las
consultas. SQL permite el empleo de expresiones aritmticas, pero adems permite el uso de
operadores de agregacin, tales como MIN o SUM, que representan una ampliacin significativa
del lgebra relacional. SQL soporta cinco operadores de agregacin, que se pueden aplicar a
cualquier columna de una relacin dada, a saber:
COUNT ([DISTINCT] columna): el nmero de valores (nicos) de la columna en cuestin.
SUM ([DISTINCT] columna): suma de todos los valores (nicos) de la columna en cuestin.
AVG ([DISTINCT] columna): promedio de todos los valores (nicos) de la columna.
MAX (columna): el valor mximo de la columna en cuestin.
MIN (columna): el valor mnimo de la columna en cuestin.
Veamos ejemplos:
(C25) Averiguar el promedio de edad de los marineros.
SELECT AVG M.edad

FROM Marineros M
(C26) Averiguar el promedio de edad de los marineros cuya categora es 10.
SELECT AVG M.edad

FROM Marineros M
WHERE M.categora=10
Ao 2010
Pgina 17


GESTIN DE DATOS
Para averiguar la edad del marinero ms joven (o ms viejo) se puede usar MIN (o MAX) en lugar
de AVG. Ahora, si adems queremos el nombre de ese marinero, no es tan simple como poner
SELECT MIN M.edad, M.nombrem. Esta consulta es ilegal en SQL (si la clusula SELECT
emplea una operacin de agregacin, solo debe emplear operaciones de agregacin, a menos
que la consulta contenga alguna clusula GROUP BY). Por lo tanto habra que escribir:
SELECT M.nombrem, M.edad

FROM Marineros M
WHERE M.edad = ( SELECT MIN (M2.edad)
FROM Marineros M2)
Observemos que se utiliza el resultado de una operacin de agregacin en la subconsulta como
argumento de una operacin de comparacin. Estamos comparando un valor de edad con el
resultado de la subconsulta, que es una relacin. Sin embargo, debido al empleo de la operacin
de agregacin, se garantiza que la subconsulta devuelve una sola tupla con un solo campo, y SQL
convierte esa relacin en un valor de campo a fines de la comparacin. La siguiente consulta, si
bien es legal para SQL, muchos sistemas no la soportan:
SELECT M.nombrem, M.edad

FROM Marineros M
WHERE ( SELECT MIN (M2.edad)
FROM Marineros M2) = M.edad
Se puede contar el nmero de marineros con COUNT. Este ejemplo ilustra el empleo de * como
argumento de COUNT, que resulta til cuando se desea contar todas las filas.
(C28) Contar el nmero de marineros.
SELECT COUNT (*)

FROM Marineros M
Se puede considerer * una abreviatura de todas las columnas.
(C29) Contar el nmero de nombres de marineros diferentes.
SELECT COUNT (DISTINCT M.nombrem)

FROM Marineros M
Los operadores de agregacin ofrecen una alternativa al uso de las estructuras ANY y ALL. Por
ejemplo, consideremos la siguiente consulta:
(C30) Averiguar nombre de los marineros de ms edad que el marinero ms viejo de categora 10.
SELECT M.nombrem
FROM Marineros M
WHERE M.edad > ( SELECT MAX (M2.edad)
FROM Marineros M2
WHERE M2.categora=10)
Empleando ALL esta consulta se podra escribir:
SELECT M.nombrem
FROM Marineros M
WHERE M.edad > ALL (SELECT M2.edad
FROM Marineros M2
WHERE M2.categora=10)
La consulta usando ALL es ms susceptible de sufrir errores. El empleo de ANY se corresponde
con el de MIN en lugar de MAX.
Ao 2010
Pgina 18


GESTIN DE DATOS
Ordenacin de datos resultantes

Si se desea que, al hacer una consulta, los datos aparezcan en un orden determinado, es preciso
utilizar la clusula ORDER BY en la sentencia SELECT, que se escribe de la siguiente forma:
SELECT [DISTINCT] columnas
FROM Tablas
[WHERE condiciones]
[ORDER BY columna-a-ordenar [DESC][, columna2-a-ordenar [DESC]]]
Si no se especifica DESC seguir el orden ascendente por defecto. Se puede ordenar
considerando varios niveles de ordenacin, siempre la que se escribe primero es el primer nivel de
ordenacin, y as sucesivamente.
La clusula GROUP BY y HAVING

Hasta ahora hemos aplicado las operaciones de agregacin a todas las filas de la relacin. Pero a
menudo se desea aplicar operaciones de agregacin a cada uno de los grupos de filas de una
relacin, donde el nmero de grupos depende del ejemplar de esa relacin (es decir, no se
conoce con antelacin). Por ejemplo, consideremos la siguiente consulta:
(C31) Averiguar la edad del marinero ms joven de cada categora.
Si sabemos que las categoras son enteros que van del 1 al 10, se pueden escribir diez consultas
de esta forma:
SELECT MIX (M.edad)

FROM Marineros M
WHERE M.categora=i
Donde i= 1, 2, 3,.., 10. Escribir estas diez consultas puede resultar tedioso, sin contar que quizs
no sepamos cuantas categoras hay.
La clusula GROUP BY permite escribir consultas como esta de manera mucho ms simple.
SELECT M.categora, MIX (M.edad)

FROM Marineros M
GROUP BY M.categora
La forma general del uso de esta clusula es:
SELECT [DISTINCT] columnas

FROM Tablas
[WHERE condiciones]
GROUP BY columnas-segn-las-cuales-se-quiere-agrupar
[HAVING condicin-sobre-grupos]
[ORDER BY columna-a-ordenar [DESC][, columna2-a-ordenar [DESC]]]
En las columnas que aparecen en el SELECT deben si o si estar incluidas las columnas que se
usan para agrupar. El motivo es que cada fila del resultado de la consulta se corresponde con un
grupo, que es un conjunto de filas que concuerdan con los valores de las columnas-segn-lascuales-se-quiere-agrupar. En general, si una columna aparece en el SELECT pero no en las
columnas-segn-las-cuales-se-quiere-agrupar, puede haber varias filas de un mismo grupo que
tengan valores diferentes en esa columna, y no resulta evidente el valor que se le debe asignar en
la fila de la respuesta.
La clusula HAVING permite especificar condiciones a los agrupamientos realizados con GROUP
BY. Del mismo modo que existe la clusula WHERE para filas individuales en la sentencia
SELECT, tambin se puede especificar una condicin para grupos de registros. Al utilizar la
clusula HAVING no se incluyen aquellos grupos que no cumplan una determinada condicin. La
clusula HAVING siempre va detrs de la clusula GROUP BY y no puede existir sin sta.
Veamos mediante un ejemplo el uso de estas clusulas:
Ao 2010
Pgina 19


GESTIN DE DATOS
(C32) Averiguar la edad del marinero ms joven que tiene derecho a voto (es decir, es mayor a 18
aos) para cada categora que tenga, como mnimo, dos marineros con derecho a voto.
SELECT M.categora, MIN (M.edad) AS edadmn

FROM Marineros M
WHERE M.edad >= 18
GROUP BY M.categora
HAVING COUNT (*) > 1
Lo primero que haramos es calcular el producto cartesiano entre las tablas del FROM, que en este
ejemplo no hace falta ya que usamos una sola relacin. El segundo paso es aplicar la clusula
WHERE, M.edad >= 18, eliminando aquellas filas que no cumplen con esa condicin. El tercer
paso es eliminar las columnas que no necesitamos (las que no aparecen en la clusula SELECT,
la clusula GROUP BY o la clusula HAVING). Si hay filas idnticas en este resultado, al no
especificar DISTINCT no se eliminan los duplicados. El cuarto paso es ordenar la tabla
resultante de acuerdo con la clusula GROUP BY para identificar los grupos. El quinto paso es
aplicar la condicin de la clusula HAVING, es decir, la condicin COUNT (*) > 1. Observemos que
el orden en que se toman en consideracin las clusulas WHERE y GROUP BY es significativo: si
no se toma en consideracin primero el WHERE cambiara el resultado, y sera un error. Y el sexto
paso es generar una fila de respuesta para cada grupo restante. La fila de respuesta
correspondiente a cada grupo consiste en un subconjunto de las columnas de agrupacin, y una o
ms columnas generadas mediante la aplicacin de un operador de agregacin. En este ejemplo,
cada fila de respuesta tiene una columna categora y una columna edadmn, que se calcula
aplicando MIN a los valores de la columna edad del grupo correspondiente.
Ms ejemplos de consultas de agregacin
(C33) Para cada barco rojo, averiguar el nmero de reservas realizadas.
SELECT B.idb, COUNT (*) AS numreservas

WHERE B.idb=R.idb AND B.color= rojo
GROUP BY B.idb
Observemos que si quisiramos escribir la consulta como mostramos abajo, esto sera ilegal:
SELECT B.idb, COUNT (*) AS numreservas

WHERE B.idb=R.idb
GROUP BY B.idb
HAVING B.color= rojo
Aunque la condicin para agrupar B.color= rojo tiene un solo valor para cada grupo, ya que el
atributo de agregacin idb es clave en barcos (y por lo tanto determina color), y por ello SQL no
permite esta consulta. Slo pueden aparecer en la clusula HAVING las columnas que aparecen
en la clusula GROUP BY, a menos que aparezca como argumento de algn operador de
agregacin de la clusula HAVING.
An as, esta consulta se podra reescribir fcilmente usando SQL:1999 o superior, empleando la
clusula EVERY en la clusula HAVING, escribiendo HAVING EVERY B.color= rojo. La
palabra clave EEVRY exige que todas las filas de cada grupo satisfaga la condicin que precede
para superar la condicin para grupos.
(C34) Averiguar la edad media de los marineros de cada categora que tenga, como mnimo, dos
marineros.
SELECT M.categora, AVG (M.edad) AS edadmedia
FROM Marineros M
GROUP BY M.categora
Luego de agrupar por categora, se conservan los que tienen dos marineros como mnimo.
Ao 2010
Pgina 20


GESTIN DE DATOS
La siguiente es una formulacin alternativa de la consulta, que ilustra cmo la clusula HAVING
puede tener subconsultas anidadas, al igual que la clusula WHERE. Observemos que se puede
emplear M.categora dentro de la consulta anidada de la clusula HAVING, ya que tienen un solo
valor para el grupo actual de marineros:

FROM Marineros M
GROUP BY M.categora
HAVING 1 < ( SELECT COUNT (*)
FROM Marineros M2
WHERE M.categora=M2.categora )
(C35) Averiguar la edad media de los marineros con derecho a voto (mayores de 18 aos) para
cada categora que tenga, como mnimo, dos marineros.

FROM Marineros M
WHERE M.edad >= 18
GROUP BY M.categora
FROM Marineros M2
WHERE M.categora=M2.categora )
En esta variante de la consulta C34 primero se eliminan las tuplas con edad < 18 y se agrupan
que restan por categora. La subconsulta de la clusula HAVING calcula para cada grupo el
nmero de tuplas para Marineros (sin aplicar la seleccin edad < 18) con el mismo valor de
categora que el grupo en cuestin. Si algn grupo tiene menos de dos marineros, se descarta.
Para cada grupo restante se obtiene como resultado la edad media.
(C36) Averiguar la edad media de los marineros con derecho a voto (mayores de 18 aos) para
cada categora que tenga, como mnimo, dos marineros as.

FROM Marineros M
WHERE M.edad >= 18
GROUP BY M.categora
FROM Marineros M2
WHERE M.categora=M2.categora AND M2.edad >= 18 )
Esta formulacin de la consulta C36 es realmente muy parecida a la C32, y lo podemos ver en la
siguiente formulacin alternativa, ms sencilla que la anterior:

FROM Marineros M
WHERE M.edad >= 18
GROUP BY M.categora
Esta formulacin de C36 se aprovecha del hecho de que la clusula WHERE se aplica antes de
llevar a cabo la agrupacin; por lo tanto solo quedan los marineros con edad => 18 cuando se
agrupa. Resulta instructivo considerar otra manera ms de escribir esta consulta:
SELECT Temp.categora, Temp.edadmedia

FROM (SELECT M.categora, AVG (M.edad) AS edadmedia, COUNT (*) AS numcateg
FROM Marineros M
WHERE M.edad >= 18
GROUP BY M.categora) AS Temp
WHERE Temp.numcateg > 1
Ao 2010
Pgina 21


GESTIN DE DATOS
Esta alternativa trae a colacin varios puntos interesantes. En primer lugar, la clusula FROM
tambin puede contener subconsultas anidadas de acuerdo con las normas de SQL (aunque no
todos los SGBD lo soportan). En segundo lugar, la clusula HAVING no es necesaria en lo
absoluto. Cualquier consulta con clusula HAVING se puede reescribir sin ella, pero muchas
consultas resultan ms sencillas de expresar usndola. Finalmente, cuando aparecen
subconsultas en la clusula FROM, es necesario emplear la palabra clave AS para darle nombre
(ya que en caso contrario no se puede expresar, por ejemplo, Temp.numcateg > 1).
(C37) Averiguar las categoras para las que la edad media de los marineros es mnima.
Esta consulta la usamos para ejemplificar que en las operaciones de agregacin no se permite
anidar. Podramos escribirla errneamente se la siguiente manera:
SELECT M.categora,
FROM Marineros M
WHERE AVG (M.edad) = ( SELECT MIN(AVG (M2.edad))
FROM Marineros M2
GROUP BY M2.categora)
Esta consulta no funcionara aunque se permitiera hacer MIN(AVG(M2.edad)), lo cual es ilegal. En
la consulta anidada, Marineros se divide en grupos por categoras y la edad media se calcula para
cada valor de la categora. Para cada grupo, la aplicacin de MIN a este valor medio de la edad
del grupo devuelve el mismo valor. A continuacin veremos una versin correcta de esta consulta.
SELECT Temp.categora, Temp.edadmedia

FROM ( SELECT M.categora, AVG (M.edad) AS edadmedia
FROM Marineros M
GROUP BY M.categora) AS Temp
WHERE Temp.edadmedia = ( SELECT MIN (Temp.edadmedia) FROM Temp)
Fundamentalmente calcula una tabla temporal que contiene la edad media de cada valor de
categora y luego halla la(s) categora(s) para la que esa edad media es mnima.
Valores nulos
Hasta ahora se ha asumido que los valores de las columnas para una fila dada siempre son
conocidos. En la prctica, los valores de las columnas pueden ser desconocidos. Por ejemplo,
cuando un marinero, por ejemplo dani, se hace socio de un club nutico, puede que no tenga
todava categora asignada. Dado que la definicin de la tabla Marineros tiene una columna
categora, qu fila hay que insertar para Dani? Lo que hace falta es un valor especial que denote
desconocido.
SQL ofrece un valore especial para los valores desconocidos denominado NULL (nulo) para
emplearlo en estas situaciones. Se emplea NULL cuando el valor de la columna es desconocido o
inaplicable. Esta existencia de valores NULL complica muchas situaciones en el uso de SQL.
Comparaciones que emplean valores nulos
Consideremos una comparacin como categora=8. Si se aplica a la fila de Dani, esta condicin
es verdadera o falsa? Dado que la categora de Dani es desconocida, el resultado de esta
comparacin debera ser desconocido, y de hecho es as en SQL. SQL tambin ofrece, como ya
vimos antes, el operador de comparacin especial IS NULL o IS NOT NULL.
Las conectivas lgicas AND, OR y NOT
Consideremos ahora expresiones booleanas como categora = 8 OR edad < 40, y categora = 8
AND edad < 40. Tomando a Dani nuevamente como ejemplo, como Dani es < 40, esa parte de la
comparacin toma el valor verdadero, independientemente del valor de categora, pero qu
ocurre con esa segunda parte? Solo podemos decir desconocido, como vimos antes.
NOT NULL = NULL

Verdadero/Falso OR Verdadero = Verdadero
Falso/NULL OR NULL = NULL
Verdadero AND Verdadero = Verdadero
Ao 2010
Pgina 22


GESTIN DE DATOS
Verdadero/Falso/NULL AND NULL = NULL

Verdadero/Falso AND Falso = Falso
Consecuencias para las estructuras de SQL
Las expresiones booleanas aparecen en muchos contextos de SQL, y el efecto de los valores
NULL se debe reconocer. Por ejemplo, la condicin de la clusula WHERE elimina filas (del
producto cartesiano de las tablas llamadas en FROM) para las cuales la condicin no toma el valor
verdadero. Por lo tanto, en presencia de valores NULL, cualquier fila que tome el valor falso o
NULL se elimina. La eliminacin de la fila que toma el valor NULL tiene un efecto sutil pero
significativo en las consultas, especialmente en las consultas anidadas que implican a EXIST o a
UNIQUE.
Otro problema con la presencia de valores NULL es la definicin de la consideracin como
duplicado de dos filas del mismo ejemplar de una relacin dada. La definicin de SQL es que dos
filas estn duplicadas si las columnas correspondientes son iguales o contienen valores NULL.
Comparemos esta definicin con el hecho de que, si se comparan dos valores NULL con =, el
resultado es NULL. En el contexto de los duplicados, esta comparacin se trara de manera
implcita como verdadera, lo que constituye una anomala.
Como caba esperar, todas las operaciones aritmticas +, -, * y / devuelven NULL si uno de sus
argumentos es NULL. Sin embargo, los valores NULL pueden provocar comportamientos
inesperados en las operaciones de agregacin. COUNT (*) trata a los valores NULL igual que a los
dems valores, es decir, los cuenta. Todas las dems operaciones de agregacin ( COUNT, SUM,
AVG, MIN, MAX y las variaciones con DISTINCT) se limitan a descartar los valores NULL. Como
caso especial, si unos de estos operadores que no sea COUNT se aplica solo a valores NULL,
el resultado es tambin NULL.
Reuniones externas
SQL soporta algunas variedades interesantes de la operacin reunin que aprovechan los valores
NULL, las denominadas reuniones externas. Consideremos la reunin de dos tablas, por
ejemplo Marineros C Reservas. Las tuplas de Marinero que no coinciden con ninguna fila de
Reservas segn la condicin de reunin c no aparecen en el resultado. En las reuniones externas,
por otro lado, las filas de Marineros sin filas correspondientes en Reservas aparecen en el
resultado exactamente una vez y con las columnas heredadas de Reservas asignadas a valores
NULL.
De hecho, hay diversas variedades de reunin externa. En las reuniones externas por izquierda
(LEFT JOIN) las filas de Marineros sin fila correspondiente de Reservas aparecen en el
resultado, pero no al contrario. En las reuniones externas por derecha (RIGTH JOIN) las filas
de Reservas sin filas correspondientes de Marineros aparecen en el resultado, pero no al revs.
En las reuniones externas completas (FULL OUTER JOIN) tanto las filas de Marineros como
las de Reservas sin filas correspondientes aparecen en el resultado.
SQL Permite especificar el tipo de reunin deseada en la clusula FROM. Por ejemplo, la siguiente
consulta muestra pares [idm, idb] correspondientes a marineros y a los barcos que han reservado:
SELECT M.idm, R.idb

FROM Marineros M NATURAL LEFT OUTER JOIN Reservas R
Las palabras claves NATURAL especifica que la condicin de reunin es la igualdad para todos
los atributos comunes, y no exige la clusula WHERE (a menos que desee especificar condiciones
adicionales que no afecten a la reunin).
Desactivacin de valores nulos
Se puede impedir los valores NULL especificando NOT NULL como parte de la definicin del
campo, por ejemplo, nombrem CHART(20) NOT NULL. Adems, no se permite que los campos
de la clave primaria tomen valores NULL.
Ao 2010
Pgina 23


GESTIN DE DATOS
JOINs o Reuniones
Existe una sintaxis ms concreta para realizar la operacin de reunin, donde la clusula WHERE
se usa nicamente para filtrar registros y no para reunir registros.
Reunin interna - clusulas inner join / on
Esta clusula est diseada precisamente para reunir registros de varias tablas, en ella
intervienen las claves primarias y forneas, y no intervienen, o lo hacen en la clusula WHERE, los
filtros propiamente dichos.
SELECT <select_list>
FROM Table_A A INNER JOIN Table_B B
ON A.Key = B.Key
Si antes se dijo que el SGBD realiza el producto cartesiano entre
dos tablas y posteriormente mediante la clusula WHERE ignora
aquellos registros que carecen de sentido y muestra los que
guardan una relacin, ahora podemos verlo del siguiente modo: el
SGBD recorrer la tabla A y para cada uno asociar el registro de la tabla B que satisface la
clusula ON.
Reunin externa - left outer join / right outer join
La reunin externa puede verse como una reunin interna donde no es necesario que el registro
hijo tenga informada la clave fornea para ser mostrado. La reunin externa siempre se realizara
por la izquierda o por la derecha, una de las dos. De este modo expresamos el deseo de
considerar todos los registros de la tabla a la izquierda o a la derecha de la clusula OUTER
JOIN, aunque no se hallen coincidencias con la otra tabla segn la clusula ON.
FROM Table_A A RIGHT JOIN Table_B B
ON A.Key = B.Key
FROM Table_A A LEFT JOIN Table_B B
ON A.Key = B.Key
Ao 2010
Pgina 24


GESTIN DE DATOS
Ao 2010
Pgina 25


GESTIN DE DATOS
Bibliografa
(1) Sistema de Administracin de Bases de Datos; Raghu Ramakrishnan/Johannes
Gehrke; Mc Graw Hill, 3 Edicin, edicin en espaol 2007
La mayora de los contenidos de este apunte son extrados de este libro, con
ejemplos y grficos incluidos.
(2) Fundamentos de Sistemas de Bases de Datos; Elmasri y Navathe; Addison Wesley; 3
Edicin; Madrid; 2002.
(3) Introduccin a las bases de datos relacionales; Mendelzon-Ale; Prentice may; 1 edicin;
Argentina; 2000.
(4) Concepto y diseo de bases de datos; Miguel Mario Piattini; Addison-Wesley.
(5) Fundamentos de base de datos; Korth F. Henry; McGraw Hill; 3 Edicin; 1998.
(6) Introduccin a los sistemas de base de datos; C. J. Date; Prentice-Hall; 7 Edicin; 2001.
(7) Sistemas de Bases de Datos Conceptos fundamentales; Elmasri y Navathe; Addison
Wesley; 2 Edicin; Madrid; 1994.
Ao 2010
Pgina 26

UNidad 3 para Gestion de Datos

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

UNidad 3 para Gestion de Datos

Uploaded by

Copyright:

Available Formats

UNIVERSIDAD TECNOLGICA NACIONAL

FACULTAD REGIONAL RESISTENCIA

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin

Ing. Carolina Orcola

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin

Unidad VI: SQL

Lenguaje de Manipulacin de Datos (LMD). Este subconjunto de SQL permite a los

Lenguaje de Definicin de Datos (LDD). Este subconjunto de SQL soporta la creacin,

Disparadores y restricciones de integridad avanzadas. Las normas de SQL:1999 ya

Ing. Carolina Orcola

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin

SQL incorporado y SQL dinmico. Las caractersticas de SQL incorporado permiten

Ejecucin cliente-servidor y acceso a bases de datos remotas. Estas rdenes

Gestin de transacciones. Diversas rdenes permiten que los usuarios controlen de

Caractersticas avanzadas. Las normas SQL:1999 incluyen caractersticas orientadas a

Formas de las consultas SQL Bsicas

SELECT [DISTINCT] lista-de-seleccin

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin

relacional es la base de la optimizacin de las consultas en los SGBD relacionales. En realidad,

Respuesta a C15 sin DISTINCT

SELECT M.idm, M.nombrem, M.categora, M.edad

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin

Veamos la sintaxis de las consultas e SQL con mayor detalle:

La lista-de-tablas de la clusula FROM es una lista de nombres de tablas. El nombre de

La lista-de-seleccin es una lista de (expresiones que implican a) nombres de columna de

La condicin de la clusula WHERE es una combinacin booleana (es decir, una

idb=103 ( nombrem (Reservas Marineros) )

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin

nombrem (color=rojo (Barcos) Reservas Marineros)

Ing. Carolina Orcola

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin

(C3) Averiguar el color de los barcos reservados por Lpez.

color (nombrem=Lpez (Marineros) Reservas Barcos)

nombrem (Marineros Reservas)

SELECT M.nombrem, M.categora+1 AS categora

SELECT M1.nombrem AS nombre1, M2.nombrem AS nombre2

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin

Ing. Carolina Orcola

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin

SELECT M.idm, M.nombrem

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin

Si simplemente se tuviera que sustituir el operador OR en la clusula WHERE por el de AND, en

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin

Interseccin utilizando EXISTS

Ing. Carolina Orcola

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin

Interseccin utilizando NOT EXISTS

Universidad Tecnolgica Nacional

Ingeniera en Sistemas de Informacin