unidad 3 para gestion de datos

8/18/2019 UNidad 3 para gestion de datos

1/26

UNIVERSIDAD TECNOLÓGICA NACIONALFACULTAD REGIONAL RESISTENCIA

INGENIERÍA EN SISTEMASDE INFORMACIÓN

GESTIÓN DE DATOS

APUNTES TEÓRICOS

Unidad 6: SQL Profesor Teoría: Ing. Carolina Orcola

Jefe de T. P.: Ing. Luis Eiman Auxiliar de T.P.: Juan Carlos Fernandez


2/26

Universidad Tecnológica Nacional Ingeniería en Sistemas de InformaciónFacultad Regional Resistencia GESTIÓN DE DATOS

Ing. Carolina Orcola Año 2010 Página 2

Índice

Unidad VI: SQL ............................................................................................................................... 3

Introducción ................................................................................................................................ 3

Formas de las consultas SQL Básicas ........................................................................................ 4

Ejemplos de consultas básicas 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

Más ejemplos de consultas anidadas .................................................................................... 16

Operadores de agregación ........................................................................................................ 17

Ordenación de datos resultantes ............................................................................................... 19

La cláusula GROUP BY y HAVING ............................................................................................. 19

Más ejemplos de consultas de agregación ............................................................................ 20

Valores nulos ............................................................................................................................ 22

Comparaciones que emplean valores nulos .......................................................................... 22

Las conectivas lógicas AND, OR y NOT ................................................................................ 22

Consecuencias para las estructuras de SQL ......................................................................... 23

Reuniones externas .............................................................................................................. 23

Desactivación de valores nulos ............................................................................................. 23

JOINs o Reuniones ................................................................................................................... 24

Reunión interna - cláusulas inner join / on ............................................................................. 24

Reunión externa - left outer join / right outer join ................................................................... 24

¿Que trae de nuevo SQL Server 2008? ....................................... ¡Error! Marcador no definido.

Bibliografía .................................................................................................................................... 26


3/26



Unidad VI: SQLEl Lenguaje Estructurado de Consultas (Structured Query Lenguage, SQL) es el lenguajecomercial de base de datos relacionales más utilizado.Los orígenes del SQL están ligados a los de las bases de datos relacionales. En 1970 E. F. Coddpropone el modelo relacional y asociado a éste un sublenguaje de acceso a los datos basado enel cálculo de predicados. Basándose en estas ideas, los laboratorios de IBM definen el lenguajeSEQUEL (Structured English QUEry Language) que más tarde sería ampliamente implementadopor el SGBD (Sistemas Gestores de Bases de Datos) experimental System R, desarrollado en1977 también por IBM. Sin embargo, fue Oracle quien lo introdujo por primera vez en 1979 en unprograma comercial.El SEQUEL terminaría siendo el predecesor de SQL, siendo éste una versión evolucionada delprimero. El SQL pasa a ser el lenguaje por excelencia de los diversos SGBD relacionales surgidosen los años siguientes y es por fin estandarizado en 1986 por el ANSI, dando lugar a la primeraversión estándar de este lenguaje, el "SQL-86" o "SQL1". Al año siguiente este estándar estambién adoptado por la ISO.Sin embargo, este primer estándar no cubre todas las necesidades de los desarrolladores eincluye funcionalidades de definición de almacenamiento que se consideraron suprimir. Así que en1992 se lanza un nuevo estándar ampliado y revisado del SQL llamado "SQL-92" o "SQL2".En la actualidad el SQL es el estándar de facto de la inmensa mayoría de los SGBD comerciales.Y, aunque la diversidad de añadidos particulares que incluyen las distintas implementacionescomerciales del lenguaje es amplia, el soporte al estándar SQL-92 es general y muy amplio.El ANSI SQL sufrió varias revisiones y agregados a lo largo del tiempo:Año Nombre Alias Comentarios1986 SQL-86 SQL-87 Primera publicación hecha por ANSI. Confirmada por ISO en 1987. 1989 SQL-89 Revisión menor.1992 SQL-92 SQL2 Revisión mayor.1999 SQL:1999 SQL2000 Se agregaron expresiones regulares, consultas recursivas (para relaciones

jerárquicas), triggers y algunas características orientadas a objetos.2003 SQL:2003 Introduce algunas características de XML, cambios en las funciones,

estandarización del objeto sequence y de las columnas autonumericas. (VerEisenberg et al.: SQL:2003 Has Been Published .)

2006 SQL:2006 ISO/IEC 9075-14:2006 Define las maneras en las cuales el SQL se puede utilizarconjuntamente con XML. Define maneras importar y guardar datos XML en unabase de datos SQL, manipulándolos dentro de la base de datos y publicando elXML y los datos SQL convencionales en forma XML. Además, proporcionafacilidades que permiten a las aplicaciones integrar dentro de su código SQL el usode XQuery, lenguaje de consulta XML publicado por el W3C (World Wide WebConsortium) para acceso concurrente a datos ordinarios SQL y documentos XML.

2008 SQL:2008 Permite el uso de la cláusula ORDER BY fuera de las definiciones de los cursores.Incluye los disparadores del tipo INSTEAD OF. Añade la sentencia TRUNCATE.

Introducción

El lenguaje SQL tiene varios aspectos diferentes: Lenguaje de Manipulación de Datos (LMD). Este subconjunto de SQL permite a los

usuarios formular consultas e insertar, eliminar y modificar filas. Lenguaje de Definición de Datos (LDD). Este subconjunto de SQL soporta la creación,

eliminación y modificación de definiciones de tablas y vistas. Se pueden definirrestricciones de integridad para las tablas, ya sea en el momento de crearlas oposteriormente.

Disparadores y restricciones de integridad avanzadas. Las normas de SQL:1999 yaincluyen soporte para los disparadores (Triggers), que son acciones ejecutadas por elSGBD siempre que las modificaciones de la base de datos cumplen las condicionesespecificadas en el disparador.

http://wapedia.mobi/es/1986http://wapedia.mobi/es/1986http://wapedia.mobi/es/SQL-87http://wapedia.mobi/es/SQL-87http://wapedia.mobi/es/International_Organization_for_Standardizationhttp://wapedia.mobi/es/International_Organization_for_Standardizationhttp://wapedia.mobi/es/International_Organization_for_Standardizationhttp://wapedia.mobi/es/1987http://wapedia.mobi/es/1987http://wapedia.mobi/es/1987http://wapedia.mobi/es/1989http://wapedia.mobi/es/1989http://wapedia.mobi/es/SQL-89http://wapedia.mobi/es/SQL-89http://wapedia.mobi/es/1992http://wapedia.mobi/es/1992http://wapedia.mobi/es/SQL-92http://wapedia.mobi/es/SQL-92http://wapedia.mobi/es/1999http://wapedia.mobi/es/1999http://wapedia.mobi/es/SQL1999http://wapedia.mobi/es/SQL1999http://wapedia.mobi/es/2003http://wapedia.mobi/es/2003http://wapedia.mobi/es/SQL2003http://wapedia.mobi/es/SQL2003http://wapedia.mobi/es/XMLhttp://wapedia.mobi/es/XMLhttp://wapedia.mobi/es/XMLhttp://www.acm.org/sigmod/record/issues/0403/index.html#standardshttp://www.acm.org/sigmod/record/issues/0403/index.html#standardshttp://www.acm.org/sigmod/record/issues/0403/index.html#standardshttp://wapedia.mobi/es/2006http://wapedia.mobi/es/2006http://wapedia.mobi/es/SQL2006http://wapedia.mobi/es/SQL2006http://wapedia.mobi/es/2008http://wapedia.mobi/es/2008http://wapedia.mobi/es/SQL2008http://wapedia.mobi/es/SQL2008http://wapedia.mobi/es/SQL2008http://wapedia.mobi/es/2008http://wapedia.mobi/es/SQL2006http://wapedia.mobi/es/2006http://www.acm.org/sigmod/record/issues/0403/index.html#standardshttp://wapedia.mobi/es/XMLhttp://wapedia.mobi/es/SQL2003http://wapedia.mobi/es/2003http://wapedia.mobi/es/SQL1999http://wapedia.mobi/es/1999http://wapedia.mobi/es/SQL-92http://wapedia.mobi/es/1992http://wapedia.mobi/es/SQL-89http://wapedia.mobi/es/1989http://wapedia.mobi/es/1987http://wapedia.mobi/es/International_Organization_for_Standardizationhttp://wapedia.mobi/es/SQL-87http://wapedia.mobi/es/1986


4/26



SQL incorporado y SQL dinámico. Las características de SQL incorporado permitenllamar al código SQL desde lenguajes anfitriones como C o Cobol.

Ejecución cliente-servidor y acceso a bases de datos remotas. Estas órdenescontrolan el modo en que los programas de aplicación cliente pueden conectarse con losservidores de la base de datos de SQL o tener acceso a los datos de la base de datos através de la red.

Gestión de transacciones. Diversas órdenes permiten que los usuarios controlen demanera explícita aspectos del modo en que se deben ejecutar las transacciones.

Seguridad. SQL ofrece mecanismos para controlar el acceso de los usuarios a los objetosde datos, como tablas y vistas.

Características avanzadas. Las normas SQL:1999 incluyen características orientadas aobjetos, consultas de apoyo a decisiones, y también aborda áreas emergentes como laminería de datos, datos espaciales y gestión 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 nombrem categoria edad

22 Dominguez 7 45,029 Barvo 1 33,031 Lorca 8 55,5

32 Alández 8 25,558 Rubio 10 35,064 Horacio 7 35,071 Zuazo 10 16,074 Horacio 9 35,085 Arturo 3 25,595 Benito 3 63,5

Form as de las co ns ultas SQL Básic as

La forma básica de las consultas de SQL son:SELECT [DISTINCT ] lista-de-selecciónFROM lista-de-tablas

WHERE condiciónTodas las consultas deben tener una cláusula SELECT , que especifica las columnas que sedeben conservar en el resultado, y una cláusula FROM , que especifica un producto cartesiano de

las tablas que allí se enuncian. La cláusula opcional WHERE especifica las condiciones deselección para las tablas indicadas en FROM .Una consulta así, intuitivamente, corresponde a una expresión del álgebra relacional que implicaselecciones, proyecciones y productos cartesianos. La estrecha relación entre SQL y el álgebra

R2 idm idb fecha22 101 10/10/200822 102 10/10/200822 103 10/8/2008

22 104 10/7/200831 102 11/10/200831 103 11/6/200831 104 11/12/200864 101 9/5/200864 102 9/8/200874 103 9/8/2008

B1 idb nombreb color101 Intrépido azul102 Intrépido rojo

103 Campeón verde104 Místico rojo


5/26



relacional es la base de la optimización de las consultas en los SGBD relacionales. En realidad,los planes de ejecución de las consultas SQL se presentan mediante una variación de lasexpresiones 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.edadFROM Marineros M

La respuesta es un conjunto de filas, cada una de ellas es un par ( nombrem, edad ). Si dos o másmarineros tienen el mismo nombre y la misma edad, la respuesta sigue teniendo una sola parejacon ese nombre y esa edad. Esta consulta es equivalente a la aplicación del operador proyeccióndel álgebra relacional.Si se omite la palabra clave DISTINCT , se obtendrá una copia de la fila ( n,e ) por cada marinerode nombre n y edad e ; la respuesta sería un multiconjunto de filas. Los multiconjuntos se parecena los conjuntos en que son colecciones desordenadas de elementos, pero en los multiconjuntospuede haber varias copias de cada elemento y el número de copias es significativo –dosmulticonjuntos pueden tener los mismos elementos y ser diferentes porque el número de copiasde algún elemento sea diferente-. Por ejemplo, {a,b,b} y {b,a,b} denotan el mismo multiconjunto, yson diferentes del multiconjunto {a,a,b}.La respuesta a esta consulta, con o sin la palabra DISTINCT , para el ejemplar M3 de Marinerose puede ver en las figuras siguientes. La única diferencia es que la tupla de Horacio aparece dosveces si se omite DISTINCT , esto se debe a que hay dos marineros que se llaman Horacio ytienen 35 años.

nombrem edadDominguez 45,0Barvo 33,0Lorca 55,5 Alández 25,5

Rubio 35,0Horacio 35,0Zuazo 16,0Horacio 35,0 Arturo 25,5Benito 63,5

Respuesta a C15 sin DISTINCT Respuesta a C15

La siguiente consulta es equivalente a una aplicación del operador selección del álgebrarelacional.(C11) Averiguar todos los marineros con categoría superior a 7.

{M | M Marineros M.categoria > 7 } En Cálculo Relacional de Tuplas

SELECT M.idm, M.nombrem, M.categoría, M.edadFROM Marineros AS M

WHERE M.categoría > 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 alternativade abreviar la consulta escribiendo directamente SELECT * . Esta notación resulta útil para lasconsultas interactivas, pero no es una buena práctica para las consultas que se pretende volver autilizar y conservar, ya que el esquema del resultado no queda claro desde la propia consulta; hayque hacer referencia al propio esquema de la tabla Marineros subyacente.La cláusula SELECT se emplea realmente para hacer proyecciones , mientras que las selecciones en el sentido del álgebra relacional se expresan mediante la cláusula WHERE . Este desajuste entrela denominación de los operadores selección y proyección del álgebra relacional y la sintaxis deSQL es un accidente histórico desafortunado.

nombrem edadDominguez 45,0Barvo 33,0Lorca 55,5 Alández 25,5

Rubio 35,0Horacio 35,0Zuazo 16,0 Arturo 25,5Benito 63,5


6/26



Veamos la sintaxis de las consultas e SQL con mayor detalle: La lista-de-tablas de la cláusula 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 resultanespecialmente útiles cuando el mismo nombre de tabla aparece más de una vez en estalista.

La lista-de-selección es una lista de (expresiones que implican a) nombres de columna detabla que se mencionan en la lista-de-selección. A los nombres de columna se le puedenanteponer una variable de rango.

La condición de la cláusula WHERE es una combinación booleana (es decir, unaexpresión que emplea las conectivas lógicas AND , OR y NOT ) de condiciones de la formaexpresión op expresión , donde op es alguno de los operadores de comparación {}. Unaexpresión es un nombre de columna , una constante o una expresión(aritmética o cadena de caracteres).

La palabra clave DISTINCT es opcional. Indica que la tabla calculada como respuesta ala consulta no debe contener duplicados , es decir, dos copias de la misma fila. El valorpredeterminado es que los duplicados no se eliminan.

Aunque las reglas anteriores describen (de manera informal) la sintaxis de las consultas básicasde SQL, no indican el significado de las consultas. La respuesta de las consultas es en si mismauna relación –que es un multiconjunto de filas en SQL_ cuyo contenido se puede comprenderconsiderando la siguiente estrategia de evaluación 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 condición .3. Eliminar todas las columnas que no aparezcan en la lista-de-selección .4. Si se especifica DISTINCT , eliminar las filas repetidas.

Esta sencilla estrategia de evaluación conceptual explicita las filas que deben encontrarse en larespuesta 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.nombremFROM 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 menostedioso el ejemplo).M4 idm nombrem categoria edad

22 Dominguez 7 45,031 Lorca 8 55,558 Rubio 10 35,0

El primer paso es crear el producto cartesiano de M4XR3 , que podemos ver en la siguiente figura.idm nombrem categoria edad Idm idb fecha22 Dominguez 7 45,0 22 101 10/10/200822 Dominguez 7 45,0 58 103 11/12/200831 Lorca 8 55,5 22 101 10/10/200831 Lorca 8 55,5 58 103 11/12/200858 Rubio 10 35,0 22 101 10/10/200858 Rubio 10 35,0 58 103 11/12/2008

R3 Idm idb fecha22 101 10/10/200858 103 11/12/2008


7/26



El segundo paso es aplicar la condición M.ide = R.ide AND R.ide = 103 . Este paso elimina todaslas filas del ejemplar resultante del producto cartesiano visto antes menos la última.

idm Nombrem categoria edad Idm idb fecha58 Rubio 10 35,0 58 103 11/12/2008

El tercer paso es eliminar las columnas no deseadas; solo aparece nombrem en la cláusulaSELECT . Este paso deja entonces una sola columna y una sola fila, que es la siguiente:

nombremRubio

Ejemp los d e cons ultas b ásic as de SQL

A continuación se presentan varios ejemplos de consultas SQL, muchas de las cuales ya seexpresaron anteriormente en el álgebra relacional y el cálculo relacional. El primer ejemplo ilustraque el empleo de variables de rango es opcional, a menos que sea necesario para resolver algunaambigüedad. La consulta C1, que ya se vió antes, también se puede expresar de la siguientemanera:

SELECT nombrem

FROM Marineros M, Reservas R WHERE M.ide = R.ide AND ide = 103

Sólo hay que cualificar las apariciones de idm , ya que esta columna aparece en las dos tablasvinculadas a la consulta. Otra manera equivalente de escribir esta consulta sería:

SELECT nombremFROM 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 implícitacomo variables de fila. Sólo hace falta introducir variables de rango de manera explícita cuando lacláusula FROM contiene más de una aparición de una misma relación. No obstante, serecomienda el empleo explícito de las variables de rengo y la condición completa de todas lasapariciones de las columnas con una variable de rango para mejorar la legibilidad de lasconsultas.(C16) Averiguar el idm de los marineros que han reservado barcos rojos.

SELECT R.idmFROM Barcos B, Reservas R

WHERE B.idb = R.idb AND B.color = “rojo”

Esta consulta contiene una reunión de dos tablas, seguida de una selección del color de losbarcos. 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.nombremFROM Marineros M, Reservas R, Barcos B

WHERE M.idm = R.idm AND R.idb = B.idb AND B.color = “rojo”

Esta consulta contiene una reunión de tres tablas seguida de una selección del color de losbarcos. La reunión con Marineros permite averiguar el nombre del marinero que, según la tupla Rde Reservas, ha reservado el barco rojo descripto por la tupla B.


8/26



(C3) Averiguar el color de los barcos reservados por López.


color (σ nombrem= ”López” (Marineros) Reservas Barcos)En SQL:

SELECT B.colorFROM Marineros M, Reservas R, Barcos B WHERE M.idm = R.idm AND R.idb = B.idb AND M.nombre = “López”

Esta consulta es muy parecida a la anterior. Obsérvese que, en general, puede que haya más deun marinero llamado López (ya que nombrem no es clave de Marineros); esta consulta siguesiendo correcta en el sentido que devolverá el color de los barcos reservados por algún López, sies que hay varios marineros llamados López.(C4) Averiguar el nombre de los marineros que han reservado, como mínimo, un barco.


nombrem (Marineros Reservas)En SQL:

SELECT M.nombremFROM Marineros M, Reservas R

WHERE M.idm = R.idm

La reunión de Marineros y Reservas garantiza que, para cada nombrem seleccionado, el marinerohaya hecho alguna reserva. (Si algún marinero no ha hecho ninguna reserva, el segundo paso dela estrategia de evaluación conceptual eliminará todas las filas del producto cartesiano queimpliquen a ese marinero).Expresion es y cadenas de caracteres en la orden SELECT

SQL soporta una versión más general de la lista-de-selección que una mera lista de columnas.Cada elemento de una lista-de-selección puede ser de la forma expresión AS nombre-columna ,donde expresión es cualquier expresión aritmética o de cadena de caracteres para los nombres delas 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.También puede contener agregados como sum y count , entre otros. La norma de SQL tambiénincluye expresiones para los valores de fecha y de hora, que no se tratarán. Aunque no formanparte de la norma de SQL, muchas implementaciones soportan también el empleo de funcionespredefinidas como sqrt , sen y mod .

(C17) Calcular el incremento de la categoría de las personas que han navegado en dos barcos

diferentes el mismo día.SELECT M.nombrem, M.categoría+1 AS categoríaFROM 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

Además, cada elemento de la condición puede ser tan general como expresión1 = expresión2. SELECT M1.nombrem AS nombre1, M2.nombrem AS nombre2FROM Marineros M1, Marineros M2

WHERE 2*M1.categoría = M2.categoría-1

Para la comparación de cadenas de caracteres se pueden emplear las operaciones decomparación (=, , etc.) con el orden de la cadena de caracteres determinado alfabéticamente,como de costumbre. Si hay que ordenar las cadenas de caracteres de manera diferente a laalfabética (por ejemplo, ordenar las cadenas de caracteres que denotan el nombre de los mesessegún su orden en el calendario enero, febrero, marzo, etc.), SQL soporta el concepto general de


9/26



ordenación , u orden de colocación, para los conjuntos de caracteres. La ordenación permite queel usuario especi fique los caracteres que son “menores que” otros y ofrece gran flexibilidad para lamanipulación de cadenas de caracteres. Además, SQL ofrece soporte para la comparación de estructuras mediante el operador LIKE , junto con el uso de los símbolos % (que sustituye a cero o más caracteres arbitrarios) y _ (quesustituye exactamente a un carácter arbitrario). Así “_AB%” denota una estructura que coincida

con todas las cadenas de caracteres que contienen, como mínimo, tres caracteres, en las que elsegundo y tercer carácter son A y B respectivamente. Observemos que, a diferencia de los demásoperadores de comparación, los espacios en blanco pueden resultar significativos para eloperador LIKE (dependiendo de la ordenación del conjunto de caracteres subyacentes). Por lotanto, “Jesús”=”Jesús “ es verdadero, mientras que “Jesús” LIKE ”Jesús “ es falso. Veamos unejemplo de LIKE .

(C18) Averiguar la edad de los marineros cuyo nombre comienza con B, acaba con O y tienecomo mínimo seis caracteres.

SELECT M.edadFROM Marineros M

WHERE M.nombrem LIKE “B_%_ _ _O”

Subconsul tas o Con sul tas An idadas

Al escribir una consulta, a veces hay que expresar una condición que hace referencia a algunatabla que, a su vez, se debe calcular. Las consultas empleadas para calcular esas tablas sonsubconsultas y aparecen como parte de las consultas principales.Una subconsulta es una consulta incluida en una cláusula WHERE o HAVING (1) de otra consulta.En algunas ocasiones, para expresar ciertas condiciones no hay más remedio que obtener el valorque buscamos como resultado de una consulta.

SELECT M.nombremFROM Marineros M

WHERE M.categoria = (SELECT MAX M.categoriaFROM Marineros M)

En este ejemplo, queremos ver los nombre de los marineros que tienen la categoría máxima, ypara ello debemos primero averiguar cuál es esa categoría máxima (usamos la función deagregación MAX que veremos luego).(1) La cláusula HAVING la vemos después.

Otros predicados

Predicado BETWEEN

Para expresar una condición que quiere encontrar un valor entre unos límites concretos podemosusar el predicado BETWEEN.

SELECT columnasFROM tabla

WHERE columna BETWEEN límite1 AND límite2

Por ejemplo, queremos ver los marineros cuyo rango de edad está entre 20 y 35 años:SELECT M.nombremFROM Marineros M

WHERE

M.edad BETWEEN 20 AND 35


10/26



Predicado IN

Para comprobar si un elemento coincide con los elementos de una lista utilizaremos IN , y paraver si no coinciden NOT IN .


WHERE

columna [ NOT] IN (valor1 … valorN) Por ejemplo, queremos ver los marineros cuya edad sea 15, 20 y 30 años:


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:


WHERE columna IS [NOT] NULL

Como ejemplo, supongamos que la tabla Marineros tiene una columna más hijos , en la que sepone la cantidad de hijos que tiene. Bajo ese supuesto, se puede escribir la consulta pidiendo elnombre de los marineros sin hijos, así:


WHERE M.hijos IS NULL

Predicado ALL o ANY/SOME

Para ver si una columna cumple con la condición de que todas sus filas ( ALL ) o algunas de susfilas ( ANY /SOME) satisfaga una condición, podemos escribir:


WHERE columna operador_comparación { ALL/ANY/SOME } subconsulta

Por ejemplo, escribimos una consulta que liste los idb de los barcos que fueron reservados pormarineros todos mayores de 18 años:

SELECT R.idbFROM Reserrvas R

WHERE R.idm = ALL SELECT M.idmFROM Marineros M

WHERE M.edad>=18

Y para ejemplificar el uso de ANY /SOME, podemos pedir que liste los idb de los barcos que fueronreservados por al menos un o algún marinero mayor de 18 años:

SELECT R.idbFROM Reserrvas R

WHERE R.idm = ANY SELECT M.idmFROM Marineros M

WHERE M.edad>=18


11/26



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 aplicaría NOTEXISTS .


WHERE [NOT] EXISTS subconsulta

Por ejemplo, para mostrar el idm y nombre de los marineros que reservaron un bote determinadopodemos también escribir:

SELECT M.idm,M.nombremFROM Marineros M

WHERE EXISTS SELECT R.idmFROM Reserrvas R

WHERE R.idb = “103”

UNION, INTERSECT y EXCEPT

SQL ofrece tres estructuras para la manipulación de conjuntos que amplía la forma básica de lasconsultas presentadas hasta aquí. Dado que la respuesta a cada consulta es un multiconjunto defilas, resulta natural considerar el empleo de operaciones como la unión, la intersección y ladiferencia de conjuntos. SQL soporta estas operaciones con los nombres de UNION,INTERSECT y EXCEPT . SQL ofrece también aplicar otras operaciones con conjuntos, quehemos 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 comprobarsi un conjunto está vacío).La cláusula UNION puede unir dos o más sentencias SELECT FROM . Su formato es:

SELECT columnaFROM tabla[ WHERE condiciones]

UNION [ALL]


Si ponemos la opción ALL , aparecerán todas las filas obtenidas a causa de la unión. No lapondremos si queremos eliminar las filas repetidas. Las tablas resultantes de las sentencias a unirdeben ser compatibles con la unión.Consideremos la siguiente consulta:(C5) Averiguar el nombre de los marineros que han reservado barcos rojos o verdes.


WHERE M.idm=R.idm AND R.idb=B.idb AND (B.color=”rojo” OR B.color=”verde”)

Esta consulta se expresa fácilmente usando el operador OR en la cláusula WHERE . Sin embargo,la siguiente consulta, que es idéntica salvo por el empleo de “y” en lugar de “o” resulta mucho másdifícil:(C6) Averiguar el nombre de los marineros que han reservado barcos rojos y verdes.


12/26



Si simplemente se tuviera que sustituir el operador OR en la cláusula WHERE por el de AND , enanalogía con la expresión escrita de las consultas, se recuperaría el nombre de los marineros quehan reservado barcos que son a la vez rojos y verdes (no los que reservaron barcos rojos y barcosverdes). La restricción de integridad de que idb es clave de Barcos indica que el mismo barco nopuede tener dos colores y, por lo tanto, la variante de la consulta anterior daría siempre resultadosvacíos. La respuesta correcta de la consulta C6 es la siguiente:

SELECT M.nombremFROM 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 reservadobarcos rojos; y de manera parecida, R2 y B2 prueban que el mismo marinero ha reservadotambién barcos verdes. M.nombrem no se incluye en el resultado a menos que se encuentrencinco filas como M, R1, B1, R2 y B2.La consulta anterior es difícil de comprender (y también ineficiente de ejecutar). Una solución másadecuada para estas dos consultas sería emplear UNION e INTERSECT .

Así, la consulta C5 se puede escribir:SELECT M.nombremFROM Marineros M, Reservas R, Barcos B

WHERE M.idm=R.idm AND R.idb=B.idb AND B.color=”rojo”

UNION

SELECT M2.nombremFROM 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 unión del conjunto de marineros que han reservado barcosrojos con el conjunto de marineros que han reservado barcos verdes.En completa simetría, la consulta C6 se escribiría:


WHERE M.idm=R.idm AND R.idb=B.idb AND B.color=”rojo”

INTERSECT

SELECT M2.nombremFROM Marineros M2, Reservas R2, Barcos B2


La cláusula INTERSECT genera la intersección entre dos o más sentencias SELECT FROM . Suformato es:


INTERSECT [ALL] SELECT columnaFROM tabla


13/26



[ WHERE condiciones]

Si ponemos la opción ALL , aparecerán todas las filas obtenidas a partir de la intersección. No lapondremos si queremos eliminar las filas repetidas.Las tablas resultantes de las sentencias a unir deben ser compatibles con la unión.

Intersección uti l izando IN SELECT columnaFROM tabla

WHERE columna IN ( SELECT columnaFROM tabla[ WHERE condiciones])

Intersección uti l izando EXISTS

SELECT columnaFROM tabla

WHERE EXISTS (SELECT *FROM tabla

WHERE condiciones)

Para hallar la diferencia entre dos o más sentencias SELECT FROM podemos utilizar la clásulaEXCEPT , que tiene este formato:


EXCEPT [ALL]


Si ponemos la opción ALL , aparecerán todas las filas obtenidas a partir de la diferencia. No lapondremos si queremos eliminar las filas repetidas. Al igual que la intersección y la unión, las relaciones que componen la diferencia deben sercompatibles con la unión, o debemos forzar que las columnas a vincular lo sean.

La diferencia es, junto con la intersección, una de las operaciones del SQL que se puede realizarde más formas diferentes. Así es que podemos encontrar la diferencia usando en vez de EXCEPTlos predicados NOT IN o NOT EXIST , de la siguiente forma:

Intersección uti l izando NOT IN


WHERE columna NOT IN ( SELECT columnaFROM tabla[ WHERE condiciones])


14/26



Intersección uti l izando NOT EXISTS


WHERE NOT EXISTS (SELECT *FROM tabla WHERE condiciones)

La siguiente consulta ilustra la operación diferencia de conjuntos en SQL:(C19) Averiguar el idm de todos los marineros que han reservado barcos rojos pero no verdes.

SELECT M.idmFROM Marineros M, Reservas R, Barcos B

WHERE M.idm=R.idm AND R.idb=B.idb

AND B.color=”rojo”EXCEPT

SELECT M2.idmFROM Marineros M2, Reservas R2, Barcos B2


Los marineros 22, 64 y 31 han reservado barcos rojos. Los marineros 22, 74 y 31 han reservadobarcos verdes. Por lo tanto, la respuesta contiene solo el idm 64.En realidad, dado que la relación Reservas contiene información sobre los idms, no hay necesidadalguna de consultar a la relación Marineros, y se puede simplificar la consulta de la siguientemanera:

SELECT R.idmFROM Reservas R, Barcos B

WHERE R.idb=B.idb AND B.color=”rojo”EXCEPT

SELECT R2.idmFROM Reservas R2, Barcos B2

WHERE R2.idb=B2.idb AND B2.color=”verde”

Obsérvese que esta consulta confía en la integridad referencial; es decir, no hay reservas demarineros que no existan. Tengamos en cuenta que UNION, INTERSECT y EXCEPT se puedenemplear en cualquier par de tablas compatibles con la unión, es decir, que tengan el mismonúmero de columnas y esas columnas, tomadas en orden, se correspondan sus dominios. Porejemplo se puede escribir la siguiente consulta:(C20) Averiguar el idm de los marineros que tengan una categoría de 10 o hayan reservado elbarco 104.

SELECT M.idmFROM Marineros M,

WHERE M.categoría=10

UNION

SELECT R.idmFROM Reservas R,

WHERE R.idb=104


15/26



La primer parte de la unión devuelve los idms 58 y 71. La segunda parte devuelve 22 y 31. Larespuesta es, por lo tanto, el conjunto de idms 22, 31, 58 y 71. Un último punto a destacar sobre laUNION, INTERSECT y EXCEPT es: a diferencia del criterio predeterminado de que de la formabásica de las consultas no se eliminan los duplicados a menos que se especifique DISTINCT , elcriterio predeterminado para las consultas UNION es que los duplicados sí se eliminan, a menosque escribamos UNION ALL , que fuerza a dejar los duplicados. Igual para el caso de

INTERSECT ALL o de EXCEPT ALL .Consul tas An idadas

Volvamos a las subconsultas o consultas anidadas, dando ejemplos de su uso. A manera deejemplo reescribiremos la siguiente consulta empleando una subconsulta anidada:(C1) Averiguar el nombre de los marineros que han reservado el barco 103

SELECT M.nombremFROM Marineros M,

WHERE M.ide IN (SELECT R.idmFROM Reservas R,

WHERE R.ide = 103)La subconsulta anidada calcula el (multi)conjunto de idms de los marineros que han reservado elbarco 103 (el conjunto contiene 22, 31 y 74 para los ejemplares R2 y M3) y la consulta de nivelsuperior 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 bastaría consustituir 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.


WHERE M.idmIN ( SELECT R.idmFROM Reservas R, WHERE R.idb IN ( SELECT B.idb

FROM Barcos B, WHERE B.color = “rojo”))

La subconsulta más interna busca el conjunto de idbs de los barcos rojos (102 y 104 para elejemplar B1). La subconsulta que se halla un nivel por encima de ella busca el conjunto de idmsde los marineros que han reservado algunos de esos barcos. Para los ejemplares B1, R2 y M3ese conjunto de idms contiene 22, 31 y 64. La consulta de nivel superior busca el nombre de losmarineros 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

aparición más externa de IN por NOT IN , de la siguiente manera:SELECT M.nombremFROM Marineros M,

WHERE M.idm NOT IN ( SELECT R.idmFROM Reservas R,

WHERE R.idb IN ( SELECT B.idbFROM Barcos B,

WHERE B.color = “rojo”)) Esta consulta calcula el nombre de los marineros cuyo idm no pertenece al conjunto 22, 31 y 64.

Consu ltas anidadas correlacionadas

En las consultas anidadas vistas hasta el momento la subconsulta interior ha sido completamenteindependiente de la consulta exterior. En general la subconsulta interior puede depender de la filaque se está examinando en cada momento en la consulta exterior (en términos de la estrategia deevaluación conceptual). Reescribamos una vez más la siguiente consulta:


16/26



(C1) Averiguar el nombre de los marineros que han reservado el barco 103


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 comparación de conjuntos, comoIN , permite comprobar si un conjunto no está vacío. 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 noestá vacío. Si no lo está, el marinero M ha reservado el barco 103 y se devuelve su nombre. Lasubconsulta depende claramente de la fila actual M y se debe volver a evaluar para cada fila deMarineros. La aparición de M en la subconsulta se denomina correlación , y estas consultas sedenominan consultas correlacionadas .Esta consulta también ilustra el empleo del símbolo especial * en situaciones en las que todo loque se desea hacer es comprobar si existe una fila que cumpla la condición y no se desearealmente recuperar ninguna columna de esa fila.Como ejemplo adicional, mediante el empleo de NOT EXIST en lugar de EXIST , se puedecalcular el nombre de los marineros que no han reservado barcos rojos. Estrechamenterelacionado con EXIST está el predicado UNIQUE. Cuando se aplica UNIQUE a unasubconsulta, la condición resultante devuelve verdadero si ninguna fila aparece dos veces en larespuesta de la subconsulta, es decir, si no hay ningún duplicado; en especial devuelveverdadero si la respuesta está vacía.

Más ejemp los de co ns ultas an idadas

Veamos más ejemplos de consultas anidadas:(C6) Averiguar el nombre de los marineros que han reservado barcos rojos y verdes.

SELECT M.nombremFROM Marineros M, Reservas R, Barcos B,

WHERE M.idm=R.idm AND R.idb=B.idb AND B.color=”rojo” AND M.idmIN ( SELECT M2.idm

FROM Marineros M2, Reservas R2, Barcos B2, WHERE M2.idm=R2.idm AND R2.idb=B2.idb

AND B2.color=”verde)

Esta consulta se la puede entender de la siguiente manera: “ Averiguar todos los marineros quehan reservado barcos rojos y, además, tienen idms que están incluidos en el conjunto de idms demarineros que han reservado barcos verdes.” Esta formulación de la consulta ilustra la manera enla 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 sepueden reescribir de manera parecida usando NOT IN . Para averiguar los idms de los marinerosque han reservado barcos rojos pero no barcos verdes basta con sustituir la palabra clave IN dela consulta anterior por NOT IN .


WHERE M.idmIN ( (SELECT R.idmFROM Reservas R, Barcos B,

WHERE R.idb=B.idb AND B2.color=”rojo”)INTERSECT

(SELECT R2.idmFROM Reservas R2, Barcos B2, WHERE R2.idb=B2.idb AND B2.color=”verde” ) )


17/26



Como se puede ver en la consulta anterior, escribir la consulta (C6) empleando INTERSECT resulta más complicado porque hay que utilizar los idms para identificar a los marineros (durantela intersección) y hay que devolver el nombre de los marineros.El siguiente ejemplo ilustra la manera que se puede expresar en SQL la operación división delálgebra relacional:(C9) Averiguar el nombre de los marineros que han reservado todos los barcos.

SELECT M.nombremFROM Marineros M, WHERE NOT EXIST ( (SELECT B.idb

FROM Barcos B,EXCEPT

(SELECT R.idbFROM Reservas R,

WHERE R.idm=M.idm) )

Obsérvese que esta consulta está correlacionada – para cada miembro de M se comprueba si elconjunto de barcos reservados por M incluye todos los barcos-. Una manera alternativa de llevar acabo la consulta sin emplear EXCEPT es la siguiente:


WHERE NOT EXIST ( (SELECT B.idbFROM Barcos B,

WHERE NOT EXIST (SELECT R.idbFROM Reservas R,

WHERE R.idb=B.idb AND R.idm=M.idm) )

De manera intuitiva, para cada marinero se comprueba que no hay ningún barco que no haya sidoreservado por ese marinero.

Operadores de agregación

Además de recuperar datos, a menudo se desea llevar a cabo algún cálculo o resumen en lasconsultas. SQL permite el empleo de expresiones aritméticas, pero además permite el uso deoperadores de agregación, tales como MIN o SUM , que representan una ampliación significativadel álgebra relacional. SQL soporta cinco operadores de agregación, que se pueden aplicar acualquier columna de una relación dada, a saber:

COUNT ([DISTINCT ] columna ): el número de valores (únicos) de la columna en cuestión. SUM ([DISTINCT ] columna ): suma de todos los valores (únicos) de la columna en cuestión.

AVG ([DISTINCT ] columna ): promedio de todos los valores (únicos) de la columna. MAX (columna ): el valor máximo de la columna en cuestión. MIN (columna ): el valor mínimo de la columna en cuestión.

Veamos ejemplos:(C25) Averiguar el promedio de edad de los marineros.

SELECT AVG M.edadFROM Marineros M

(C26) Averiguar el promedio de edad de los marineros cuya categoría es 10.

SELECT AVG M.edadFROM Marineros M

WHERE M.categoría=10


18/26



Para averiguar la edad del marinero más joven (o más viejo) se puede usar MIN (o MAX) en lugarde AVG. Ahora, si además queremos el nombre de ese marinero, no es tan simple como ponerSELECT MIN M.edad, M.nombrem…. Esta consulta es i legal en SQL (si la cláusula SELECTemplea una operación de agregación, solo debe emplear operaciones de agregación, a menosque la consulta contenga alguna cláusula GROUP BY ). Por lo tanto habría 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 operación de agregación en la subconsulta comoargumento de una operación de comparación. Estamos comparando un valor de edad con elresultado de la subconsulta, que es una relación. Sin embargo, debido al empleo de la operaciónde agregación, se garantiza que la subconsulta devuelve una sola tupla con un solo campo, y SQLconvierte esa relación en un valor de campo a fines de la comparación. La siguiente consulta, sibien 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 número de marineros con COUNT. Este ejemplo ilustra el empleo de * comoargumento de COUNT, que resulta útil cuando se desea contar todas las filas.(C28) Contar el número de marineros.

SELECT COUNT (*) FROM Marineros M

Se puede considerer * una abreviatura de todas las columnas.

(C29) Contar el número de nombres de marineros diferentes.

SELECT COUNT (DISTINCT M.nombrem) FROM Marineros M

Los operadores de agregación ofrecen una alternativa al uso de las estructuras ANY y ALL . Porejemplo, consideremos la siguiente consulta:(C30) Averiguar nombre de los marineros de más edad que el marinero más viejo de categoría 10.


WHERE M.edad > ( SELECT MAX (M2.edad)FROM Marineros M2

WHERE M2.categoría=10)

Empleando ALL esta consulta se podría escribir:SELECT M.nombremFROM Marineros M

WHERE M.edad > ALL (SELECT M2.edadFROM Marineros M2

WHERE M2.categoría=10)

La consulta usando ALL es más susceptible de sufrir errores. El empleo de ANY se corresponde

con el de MIN en lugar de MAX.


19/26



Ordenación de datos resultantes

Si se desea que, al hacer una consulta, los datos aparezcan en un orden determinado, es precisoutilizar la cláusulaORDER BY en la sentencia SELECT , que se escribe de la siguiente forma:

SELECT [DISTINCT ] columnasFROM 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 ordenarconsiderando varios niveles de ordenación, siempre la que se escribe primero es el primer nivel deordenación, y así sucesivamente.

La cl áusu la GROUP BY y HAVING Hasta ahora hemos aplicado las operaciones de agregación a todas las filas de la relación. Pero amenudo se desea aplicar operaciones de agregación a cada uno de los grupos de filas de unarelación, donde el número de grupos depende del ejemplar de esa relación (es decir, no seconoce con antelación). Por ejemplo, consideremos la siguiente consulta:(C31) Averiguar la edad del marinero más joven de cada categoría.Si sabemos que las categorías son enteros que van del 1 al 10, se pueden escribir diez consultasde esta forma:

SELECT MIX (M.edad)FROM Marineros M

WHERE M.categoría=i

Donde i= 1, 2, 3,.., 10. Escribir estas diez consultas puede resultar tedioso, sin contar que quizásno sepamos cuantas categorías hay.La cláusula GROUP BY permite escribir consultas como esta de manera mucho más simple.

SELECT M.categoría, MIX (M.edad)FROM Marineros MGROUP BY M.categoría

La forma general del uso de esta cláusula es:SELECT [DISTINCT ] columnasFROM Tablas[WHERE condiciones]GROUP BY columnas-según-las-cuales-se-quiere-agrupar[HAVING condición-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 seusan para agrupar. El motivo es que cada fila del resultado de la consulta se corresponde con ungrupo , que es un conjunto de filas que concuerdan con los valores de las columnas-según-las-cuales-se-quiere-agrupar. En general, si una columna aparece en el SELECT pero no en lascolumnas-según-las-cuales-se-quiere-agrupar, puede haber varias filas de un mismo grupo quetengan valores diferentes en esa columna, y no resulta evidente el valor que se le debe asignar enla fila de la respuesta.La cláusula HAVING permite especificar condiciones a los agrupamientos realizados con GROUPBY. Del mismo modo que existe la cláusula WHERE para filas individuales en la sentenciaSELECT , también se puede especificar una condición para grupos de registros. Al utilizar lacláusula HAVING no se incluyen aquellos grupos que no cumplan una determinada condición. Lacláusula HAVING siempre va detrás de la cláusula GROUP BY y no puede existir sin ésta.Veamos mediante un ejemplo el uso de estas cláusulas:


20/26



(C32) Averiguar la edad del marinero más joven que tiene derecho a voto (es decir, es mayor a 18años) para cada categoría que tenga, como mínimo, dos marineros con derecho a voto.

SELECT M.categoría, MIN (M.edad) AS edadmínFROM Marineros M

WHERE M.edad >= 18GROUP BY M.categoríaHAVING COUNT (*) > 1

Lo primero que haríamos es calcular el producto cartesiano entre las tablas del FROM , que en esteejemplo no hace falta ya que usamos una sola relación. El segundo paso es aplicar la cláusula

WHERE , M.edad >= 18, eliminando aquellas filas que no cumplen con esa condición. El tercerpaso es eliminar las columnas que no necesitamos (las que no aparecen en la cláusula SELECT ,la cláusula GROUP BY o la cláusula HAVING). Si hay filas idénticas en este resultado, al noespecificar DISTINCT no se eliminan los duplicados. El cuarto paso es ordenar la tablaresultante de acuerdo con la cláusula GROUP BY para identificar los grupos. El quinto paso esaplicar la condición de la cláusula HAVING , es decir, la condición COUNT (*) > 1. Observemos queel orden en que se toman en consideración las cláusulas WHERE y GROUP BY es significativo: si

no se toma en consideración primero el WHERE cambiaría el resultado, y sería un error. Y el sextopaso es generar una fila de respuesta para cada grupo restante. La fila de respuestacorrespondiente a cada grupo consiste en un subconjunto de las columnas de agrupación, y una omás columnas generadas mediante la aplicación de un operador de agregación. En este ejemplo,cada fila de respuesta tiene una columna categoría y una columna edadmín , que se calculaaplicando MIN a los valores de la columna edad del grupo correspondiente.Más ejemp los de co ns ultas d e agregación

(C33) Para cada barco rojo, averiguar el número de reservas realizadas.

SELECT B.idb,COUNT (*) AS numreservasFROM Barcos B, Reservas R

WHERE B.idb=R.idb AND B.color= “rojo” GROUP BY B.idb

Observemos que si quisiéramos escribir la consulta como mostramos abajo, esto sería ilegal:SELECT B.idb,COUNT (*) AS numreservasFROM Barcos B, Reservas R

WHERE B.idb=R.idbGROUP BY B.idbHAVING B.color= “rojo”

Aunque la condición para agrupar B.color= “rojo” tiene un solo valor para cada grupo, ya que elatributo de agregación idb es clave en barcos (y por lo tanto determina “color”), y por ello SQL nopermite esta consulta. Sólo pueden aparecer en la cláusula HAVING las columnas que aparecenen la cláusula GROUP BY , a menos que aparezca como argumento de algún operador deagregación de la cláusula HAVING. Aún así, esta consulta se podría reescribir fácilmente usando SQL:1999 o superior, empleando lacláusula EVERY en la cláusula HAVING , escribiendo “ HAVING EVERY B.color= “rojo””. Lapalabra clave EEVRY exige que todas las filas de cada grupo satisfaga la condición que precedepara superar la condición para grupos.(C34) Averiguar la edad media de los marineros de cada categoría que tenga, como mínimo, dosmarineros.

SELECT M.categoría, AVG (M.edad) AS edadmedia

FROM Marineros MGROUP BY M.categoríaHAVING COUNT (*) > 1

Luego de agrupar por categoría , se conservan los que tienen dos marineros como mínimo.


21/26


22/26



Esta alternativa trae a colación varios puntos interesantes. En primer lugar, la cláusula FROM también puede contener subconsultas anidadas de acuerdo con las normas de SQL (aunque notodos los SGBD lo soportan). En segundo lugar, la cláusula HAVING no es necesaria en loabsoluto. Cualquier consulta con cláusula HAVING se puede reescribir sin ella, pero muchasconsultas resultan más sencillas de expresar usándola. Finalmente, cuando aparecensubconsultas en la cláusula 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 categorías para las que la edad media de los marineros es mínima.

Esta consulta la usamos para ejemplificar que en las operaciones de agregación no se permiteanidar. Podríamos escribirla erróneamente se la siguiente manera:

SELECT M.categoría,FROM Marineros M

WHERE AVG (M.edad) = ( SELECT MIN ( AVG (M2.edad))FROM Marineros M2GROUP BY M2.categoría)

Esta consulta no funcionaría aunque se permitiera hacer MIN ( AVG (M2.edad)), lo cual es ilegal. Enla consulta anidada, Marineros se divide en grupos por categorías y la edad media se calcula paracada valor de la categoría. Para cada grupo, la aplicación de MIN a este valor medio de la edaddel grupo devuelve el mismo valor. A continuación veremos una versión correcta de esta consulta.

SELECT Temp.categoría, Temp.edadmediaFROM ( SELECT M.categoría, AVG (M.edad) AS edadmedia

FROM Marineros MGROUP BY M.categoría) AS Temp

WHERE Temp.edadmedia = ( SELECT MIN (Temp.edadmedia) FROM Temp)

Fundamentalmente calcula una tabla temporal que contiene la edad media de cada valor decategoría y luego halla la(s) categoría(s) para la que esa edad media es mínima.

Valores nulo s

Hasta ahora se ha asumido que los valores de las columnas para una fila dada siempre sonconocidos. En la práctica, los valores de las columnas pueden ser desconocidos. Por ejemplo,cuando un marinero, por ejemplo dani, se hace socio de un club náutico, puede que no tengatodavía categoría asignada. Dado que la definición de la tabla Marineros tiene una columnacategoría , ¿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) paraemplearlo en estas situaciones. Se emplea NULL cuando el valor de la columna es desconocido oinaplicable. Esta existencia de valores NULL complica muchas situaciones en el uso de SQL.

Comp araciones que emplean valores nulosConsideremos una comparación como categoría =8. Si se aplica a la fila de Dani, ¿esta condiciónes verdadera o falsa? Dado que la categoría de Dani es desconocida, el resultado de estacomparación debería ser “desconocido”, y de hecho es así en SQL. SQL ta mbién ofrece, como yavimos antes, el operador de comparación especial IS NULL o IS NOT NULL .

Las co nectivas lógicas AND, OR y NOT

Consideremos ahora expresiones booleanas como categoría = 8 OR edad < 40, y categoría = 8 AND edad < 40. Tomando a Dani nuevamente como ejemplo, como Dani es < 40, esa parte de la

comparación toma el valor verdadero, independientemente del valor de categoría , 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


23/26



Verdadero/Falso/NULL AND NULL = NULL Verdadero/Falso AND Falso = Falso

Consecu encias para las estructu ras de SQL

Las expresiones booleanas aparecen en muchos contextos de SQL, y el efecto de los valores NULL se debe reconocer. Por ejemplo, la condición de la cláusula WHERE elimina filas (del

producto cartesiano de las tablas llamadas en FROM ) para las cuales la condición no toma el valorverdadero. Por lo tanto, en presencia de valores NULL , cualquier fila que tome el valor falso o

NULL se elimina. La eliminación de la fila que toma el valor NULL tiene un efecto sutil perosignificativo en las consultas, especialmente en las consultas anidadas que implican a EXIST o aUNIQUE .Otro problema con la presencia de valores NULL es la definición de la consideración comoduplicado de dos filas del mismo ejemplar de una relación dada. La definición de SQL es que dosfilas están duplicadas si las columnas correspondientes son iguales o contienen valores NULL .Comparemos esta definición con el hecho de que, si se comparan dos valores NULL con =, elresultado es NULL . En el contexto de los duplicados, esta comparación se trara de maneraimplícita como verdadera, lo que constituye una anomalía.Como cabía esperar, todas las operaciones aritméticas +, -, * y / devuelven NULL si uno de susargumentos es NULL . Sin embargo, los valores NULL pueden provocar comportamientosinesperados en las operaciones de agregación. COUNT (*) trata a los valores NULL igual que a losdemás valores, es decir, los cuenta. Todas las demás operaciones de agregación ( COUNT, SUM ,

AVG , MIN , MAX y las variaciones con DISTINCT ) se limitan a descartar los valores NULL . Comocaso especial, si unos de estos operadores – que no sea COUNT – se aplica solo a valores NULL ,el resultado es también NULL .

Reuniones externas

SQL soporta algunas variedades interesantes de la operación reunión que aprovechan los valores NULL , las denominadas reuniones externas . Consideremos la reunión de dos tablas, por

ejemplo MarinerosC

Reservas. Las tuplas de Marinero que no coinciden con ninguna fila deReservas según la condición de reunión c no aparecen en el resultado. En las reuniones externas,por otro lado, las filas de Marineros sin filas correspondientes en Reservas aparecen en elresultado exactamente una vez y con las columnas heredadas de Reservas asignadas a valores

NULL .De hecho, hay diversas variedades de reunión externa. En las reuniones externas por izquierda(LEFT JOIN ) las filas de Marineros sin fila correspondiente de Reservas aparecen en elresultado, pero no al contrario. En las reuniones externas por derecha (RIGTH JOIN ) las filasde Reservas sin filas correspondientes de Marineros aparecen en el resultado, pero no al revés.En las reuniones externas completas (FULL OUTER JOIN ) tanto las filas de Marineros comolas de Reservas sin filas correspondientes aparecen en el resultado.SQL Permite especificar el tipo de reunión deseada en la cláusula FROM . Por ejemplo, la siguienteconsulta muestra pares [ idm, idb ] correspondientes a marineros y a los barcos que han reservado:

SELECT M.idm, R.idbFROM Marineros M NATURAL LEFT OUTER JOIN Reservas R

Las palabras claves NATURAL especifica que la condición de reunión es la igualdad para todoslos atributos comunes, y no exige la cláusula WHERE (a menos que desee especificar condicionesadicionales que no afecten a la reunión).

Desactivación de valores nulo s

Se puede impedir los valores NULL especificando NOT NULL como parte de la definición delcampo, por ejemplo, nombrem CHART(20) NOT NULL . Además, no se permite que los camposde la clave primaria tomen valores NULL .


24/26



JOINs o Reunio nes

Existe una sintaxis más concreta para realizar la operación de reunión, donde la cláusula WHERE se usa únicamente para filtrar registros y no para reunir registros.

Reunión intern a - cláus ulas inn er join / on

Esta cláusula está diseñada precisamente para reunir registros de varias tablas, en ellaintervienen las claves primarias y foráneas, y no intervienen, o lo hacen en la cláusula WHERE , losfiltros propiamente dichos.

SELECT FROM Table_A AINNER JOIN Table_B B

ON A.Key = B.Key

Si antes se dijo que el SGBD realiza el producto cartesiano entredos tablas y posteriormente mediante la cláusula WHERE ignoraaquellos registros que carecen de sentido y muestra los queguardan una relación, 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 lacláusula ON.

Reunión externa - left outer join / r ight o uter join

La reunión externa puede verse como una reunión interna donde no es necesario que el registrohijo tenga informada la clave foránea para ser mostrado. La reunión externa siempre se realizarapor la izquierda o por la derecha, una de las dos. De este modo expresamos el deseo deconsiderar todos los registros de la tabla a la izquierda o a la derecha de la cláusula OUTERJOIN , aunque no se hallen coincidencias con la otra tabla según la cláusula ON.

SELECT FROM Table_A ARIGHT JOIN Table_B BON A.Key = B.Key

SELECT FROM Table_A ALEFT JOIN Table_B B

ON A.Key = B.Key


25/26




26/26


Bibliografía

(1)“Sistema de Administración de Bases de Datos ”; Raghu Ramakrishnan/JohannesGehrke; Mc Graw Hill, 3º Edición, edición en español – 2007

La m ayor ía de los co ntenid os de este ap unte s on extraído s d e este libr o, co nejemplo s y gr áfico s inc luid os .

(2) “Fundamentos de Sistemas de Bases de Datos ”; Elmasri y Navathe; Addison Wesley; 3ºEdición; Madrid; 2002.

(3) “Introducción a las bases de datos relacionales ”; Mendelzon -Ale; Prentice may; 1º edición; Argentina; 2000.

(4) “Concepto y diseño de bases de datos ”; Miguel Mario Piattini; Addison -Wesley.

(5) “Fundamentos de base de datos ”; Korth F. Henry; McGraw Hill; 3º Edición; 1998.

(6) “Introducción a los sistemas de base de datos ”; C. J. Date; Prentice -Hall; 7º Edición; 2001.

(7) “Sistemas de Bases de Datos – Conceptos fundamentales ”; Elmasri y Navathe; AddisonWesley; 2º Edición; Madrid; 1994.

unidad 3 para gestion de datos

Documents