2.5. Consultas a una base de datos relacional

2.5. Consultas a una base de datos relacional Dataprix 18 Septiembre, 2009 - 11:35

Para hacer consultas sobre una tabla con el SQL es preciso utilizar la sentencia SELECT FROM, que tiene el siguiente formato: 

 

SELECT nombre_columna_a_seleccionar [[AS] col_renombrada]
[,nombre_columna_a_seleccionar [[AS] col_renombrada]...]
FROM tabla_a_consultar [[AS] tabla_renombrada];

La opción AS nos permite renombrar las columnas que queremos seleccionar o las tablas que queremos consultar que en este caso, es sólo una. Dicho de otro modo, nos permite la definición de alias. Fijémonos en que la palabra clave AS es opcional, y es bastante habitual poner sólo un espacio en blanco en lugar de toda la palabra.

 Consultas a BDUOC

A continuación presentamos un ejemplo de consulta a la base de datos BDUOC para conocer todos los datos que aparece en la tabla clientes: 

SELECT *
FROM clientes;

 

El * después de SELECT indicaque queremos ver todos los atributos que aparecen en la tabla.

La respuesta a esta consulta sería:

codigo_cli nombre_cli          nif            direccion ciudad telefono

10 EGICSA 38.567.893-C Aragón 11 Barcelona NULL
20 CME 38.123.898-E Valencia 22 Girona 972.23.57.67
30 ACME 36.432.127-A Mallorca 33 Lleida 973.23.45.67
40 JGM 38.782.345-B Rosellon 44 Tarragona 977.33.71.43

 

Si hubiésemos querido ver sólo el código, el nombre, la dirección y la ciudad, habríamos hecho:

SELECT codigo_cli, nombre_cli, direccion, ciudad
FROM clientes;

Y habríamos obtenido la respuesta siguiente:

codigo_cli nombre_cli direccion ciudad

10 EGICSA Aragón 11 Barcelona
20 CME Valencia 22 Girona
30 ACME Mallorca 33 Lleida
40 JGM Rosellon 44 Tarragona

 

 Con la sentencia SELECT FROM podemos seleccionar columnas de una tabla, pero para seleccionar filas de una tabla es preciso añadirle la cláusula WHERE. El formato es:

SELECT nombre_columnas_a_seleccionar
FROM tabla_a_consultar
WHERE condiciones;

La cláusula WHERE nos permite obtener las filas que cumplen la condición especificada en la consulta.

 

codigo_emple
2
4
7

Consultas a BDUOC seleccionando filas

Veamos un ejemplo en el que pedimos “los códigos de los empleados que trabajan en el proyecto número 4”:

SELECT codigo_empl
FROM empleados
WHERE num_proyec = 4;

La respuesta a esta consulta sería la que podéis ver en el margen. 

Para definir las condiciones en la cláusula WHERE, podemos utilizar alguno de los operadores de los que dispone el SQL, que son los siguientes:

 

operadores de comparación
= Igual
< Menor
> Mayor
<= Menor o igual
>= Mayor o igual
<> Diferente

 

 

Operadores lógicos
NOT Para la negación de condiciones
AND Para la conjunción de conciciones
OR Para la  disyunción de condiciones

 

 Si queremos que en una consulta nos aparezcan las filas resultantes sin repeticiones, es preciso poner la palabra clave DISTINCT inmediatamente después de SELECT. También podríamos explicitar que lo queremos todo, incluso con repeticiones, poniendo ALL (opción por defecto) en lugar de DISTINCT. El formato de DISTINCT es:

SELECT DISTINCT nombre_columnas_a_seleccionar
FROM tabla_a_consultar
[WHERE condiciones];
sueldo
30.000
40.000
70.000
90.000
100.000

Consulta a BDUOC seleccionando filas sin repeticiones

Por ejemplo, si quisiéramos ver qué sueldos se están pagando en nuestra empresa, podríamos hacer:

SELECT DISTINCT sueldo
FROM empleados;

La respuesta a esta consulta, sin repeticiones, sería la que aparece en el margen.

2.5.1. Funciones de agregacion

2.5.1. Funciones de agregacion Carlos 17 Septiembre, 2009 - 11:52

El SQL nos ofrece las siguientes funciones de agregación para efectuar varias operaciones sobre los datos de una base de datos:

Funciones de agregación
Función Descripción
COUNT Nos da el número total de filas seleccionadas
SUM Suma los valores de una columna
MIN Nos da el valor mínimo de una columna
MAX Nos da el valor máximo de una columna
AVG Calcula el valor medio de una columna

En general, las funciones de agregación se aplican a una columna, excepto la función de agregación COUNT, que normalmente se aplica a todas las columnas de la tabla o tablas seleccionadas. Por lo tanto,COUNT (*) contará todas las filas de la tabla o las tablas que cumplan las condiciones. Si se utilizase COUNT(distinct columna), sólo contaría los valores que no fuesen nulos ni repetidos, y si se utilizase COUNT(columna), sólo contaría los valores que no fuesen nulos.

Ejemplo de utilización de la función COUNT (*)

Veamos un ejemplo de uso de la función COUNT, que aparece en la cláusula SELECT, para hacer la consulta “¿Cuántos departamentos están ubicados en la ciudad de Lleida?”: 

SELECT COUNT(*) AS numero_dep
FROM departamentos
WHERE ciudad_dep = ‘Lleida’;
numero_dep
1

 

 La respuesta a esta consulta sería la que aparece reflejada en la tabla que encontraréis en el margen.
Veremos  ejemplos  de  las  demás  funciones  de  agregación  en  los  siguientes apartados. 

2.5.2. Subconsultas

2.5.2. Subconsultas Dataprix 18 Septiembre, 2009 - 11:30
Una subconsulta es una consulta incluida dentro de una cláusula WHERE o HAVING de otra consulta. En ocasiones, para expresar ciertas condiciones no hay más remedio que obtener el valor que buscamos como resultado de una consulta.

 

codigo_proyec nombre_proyec
4 TINELL

Subconsulta en BDUOC

Si quisiéramos saber los códigos y los nombres de los proyectos de precio más elevado, en primer lugar tendríamos que encontrar los proyectos que tienen el precio más elevado. Lo haríamos de la forma siguiente:

 

Los proyectos de precio más bajo
 Si en lugar de los códigos y los  nombres de los proyectos de  precio  más alto hubiésemos  querido saber  los de precio más  bajo, habríamos  aplicado la  función de agregación  MIN.

 

 

 

 

 

 

 

SELECT codigo_proyec, nombre_proyec
FROM proyectos
WHERE precio = (SELECT MAX(precio)
                FROM proyectos);

El resultado de la consulta anterior sería lo que puede verse al margen.

2.5.3. Otros predicados

2.5.3. Otros predicados Dataprix 21 Septiembre, 2009 - 09:57

1)  Predicado BETWEEN

Para expresar una condición que quiere encontrar un valor entre unos límites concretos, podemos utilizar Roman;">BETWEEN</span>:</p>
SELECT nombre_columnas_a_seleccionar
FROM tabla_a_consultar
WHERE columna BETWEEN límite1 AND límite2;


Ejemplo de uso del predicado BETWEEN

Un ejemplo en el que se pide “Los códigos de los empleados que ganan entre 20.000 y 50.000 euros anuales” sería:

SELECT codigo_empl
FROM empleados
WHERE sueldo BETWEEN 2.0E+4 and 5.0E+4;
codio_empl
5
6
7
8

La respuesta a esta consulta sería la que se ve en el margen.

 

2)  Predicado IN

Para comprobar si un valor coincide con los elementos de una lista utilizaremos IN, y para ver si no coincide, NOT IN: 

SELECT nombre_columnas_a_seleccionar
FROM tabla_a_consultar
WHERE columna [NOT] IN (valor1, ..., valorN);

Ejemplo de uso del predicado IN

“Queremos saber el nombre de todos los departamentos que se encuentran en las ciudades de Lleida o Tarragona”: 

nombre_dep
 ciudad_dep
DIS Lleida
PROG Tarragona
SELECT nombre_dep, ciudad_dep
FROM departamentos
WHERE ciudad_dep IN (‘Lleida’, ‘Tarragona’);

La respuesta sería la que aparece en el margen.

 

3)  Predicado LIKE

Para comprobar si una columna de tipo carácter cumple alguna propiedad determinada, podemos usar LIKE:

SELECT nombre_columnas_a_seleccionar
FROM tabla_a_consultar
WHERE columna LIKE característica;

Los patrones del SQL92 para expresar características son los siguientes:

Otros patrones
Aunque_y % son los caracteres elegidos por el estandar, cada sistema relacional comercial ofrece diversas variantes.

a)  Pondremos un carácter _ para cada carácter individual que queramos considerar.
b)  Pondremos un carácter % para expresar una secuencia de caracteres, que puede no estar formada por ninguno.

Ejemplo de uso del predicado LIKE

 

Atributos añadidos
Aunque la consulta pide sólo los nombres de empleados añadimos los códigos para poder diferenciar dos empleados con el mismo nombre.


A continuación presentamos un ejemplo en el que buscaremos los nombres de los empleados que empiezan por J, y otro ejemplo en el que obtendremos los proyectos que comienzan por S y tienen cinco letras:

a) Nombres de empleados que empiezan por la letra J:

SELECT codigo_empl, nombre_empl
FROM empleados
WHERE nombre_empl LIKE ‘J%’;
codigo_empl
 nombre_empl
4 Jorge

 

La respuesta a esta consulta seria la que se muestra den el margen.

b) Proyectos que empiezan por S y tienen cinco letras:

codigo_progec
3

 

SELECT codigo_proyec
FROM proyectos
WHERE nombre_proyec LIKE ‘S_ _ _ _’;

Y la respuesta a esta otra consulta sería la que aparece en el margen.

4)  Predicado IS NULL

Para comprobar si un valor es nulo utilizaremos IS NULL, y para averiguar si no lo es, IS NOT NULL. El formato es:

SELECT nombre_columnas_a_seleccionar
FROM tabla_a_consultar
WHERE columna IS [NOT] NULL;

Ejemplo de uso del predicado IS NULL

Un ejemplo de uso de este predicado sería “Queremos saber el código y el nombre de todos los empleados que no están asignados a ningún proyecto”:

codigo_emple
 nombre_emple
8 Sergio

 

SELECT codigo_empl, nombre_empl
FROM empleados
WHERE num_proyec IS NULL;

Obtendríamos la respuesta que tenemos al margen.

 

5)  Predicados ANY/SOME y ALL

Los predicados ANY/SOME
Podemos elegir cualquiera de los predicados para pedir que alguna fila satisfaga una conducción.

Para ver si una columna cumple que todas sus filas (ALL) o algunas de sus filas (ANY/SOME) satisfagan una condición, podemos hacer:

SELECT nombre_columnas_a seleccionar
FROM tabla_a_consultar
WHERE columna operador_comparación {ALL|ANY|SOME}subconsulta;

Ejemplo de uso de los predicados ALL y ANY/SOME

a) Veamos un ejemplo de aplicación de ALL para encontrar los códigos y los nombres de los proyectos en los que los sueldos de todos los empleados asignados son menores que el precio del proyecto:

SELECT codigo_proyec, nombre_proyec
FROM proyectos
WHERE precio > ALL (SELECT sueldo
                    FROM empleados
                    WHERE codigo_proyec = num_proyec);

codigo_proyec nombre_proyec
1 GESCOM
2 PESCI
3 SALSA
4 TINELL


Fijémonos en la condición de WHERE de la subconsulta, que nos asegura que los sueldos que observamos son los de los empleados asignados al proyecto de la consulta. La respuesta a esta consulta sería la que aparece en el margen.

b) A continuación, presentamos un ejemplo de ANY/SOME para buscar los códigos y los nombres de los proyectos que tienen algún empleado que gana un sueldo más elevado que el precio del proyecto en el que trabaja.

SELECT codigo_proyec, nombre_proyec
FROM proyectos
WHERE precio < ANY (SELECT sueldo
                    FROM empleados
                    WHERE codigo_proyec = num_proyec);
codigo_proyec nombre_proyec
   


La respuesta a esta consulta está vacía, como se ve en el margen.

6)  Predicado EXISTS

Para comprobar si una subconsulta produce alguna fila de resultados, podemos utilizar la sentencia denominada test de existencia: EXISTS. Para comprobar  si  una  subconsulta  no  produce  ninguna  fila  de  resultados,  podemos utilizar NOT EXISTS.

SELECT nombre_columnas_a_seleccionar
FROM tabla_a_consultar
WHERE [NOT] EXISTS subconsulta;

Ejemplo de uso del predicado EXISTS

codigo_empl nombre_empl
1
 María
2 Pedro
3 Ana
4 Jorge
5 Clara
6 Laura
7 Rogelio

Un ejemplo en el que se buscan los códigos y los nombres de los empleados que están asignados a algún proyecto sería:

SELECT codigo_empl, nombre_empl
FROM empleados
WHERE EXISTS (SELECT *
              FROM proyectos
              WHERE codigo_proyec = num_proyec);


La respuesta a esta consulta sería la que se muestra en el margen.

2.5.4. Ordenacion de los datos obtenidos en respuesta a consultas

2.5.4. Ordenacion de los datos obtenidos en respuesta a consultas Dataprix 21 Septiembre, 2009 - 10:39

Si se desea que, al hacer una consulta, los datos aparezcan en un orden determinado, es preciso utilizar la cláusula ORDER BY en la sentencia SELECT, que presenta el siguiente formato:

SELECT nombre_columnas_a seleccionar
FROM tabla_a_consultar
[WHERE condiciones]
ORDER BY columna_según_la_cual_se_quiere_ordenar [DESC]
         [, col_ordenación [DESC]...];

Consulta a BDUOC con respuesta ordenada

Imaginemos que queremos consultar los nombres de los empleados ordenados según el sueldo que ganan, y si ganan el mismo sueldo, ordenados alfabéticamente por el nombre:

SELECT codigo_empl, nombre_empl, apellido_empl, sueldo
FROM empleados
ORDER BY sueldo, nombre_empl;

Esta consulta daría la respuesta siguiente:

codigo_emple nombre_empl apellido_empl sueldo
6 Laura Tort 30.000
8 Sergio Grau 30.000
5 Clara Blanc 40.000
7 Rogelio Salt 40.000
3 Ana Ros 70.000
4 Jorge Roca 70.000
2 Pedro Mas 90.000
1 María Puig 100.000

 

 Si no se especifica nada más, se seguirá un orden ascendente, pero si se desea seguir un orden descendente es necesario añadir DESC detrás de cada factor de ordenación expresado en la cláusula ORDER BY: 

ORDER BY columna_ordenación [DESC] [, columna [DESC] ...];

También se puede explicitar un orden ascendente poniendo la palabra clave ASC (opción por defecto).

2.5.5. Consultas con agrupacion de filas de una tabla

2.5.5. Consultas con agrupacion de filas de una tabla Dataprix 21 Septiembre, 2009 - 11:09

Las cláusulas siguientes, añadidas a la instrucción SELECT FROM, permiten organizar las filas por grupos:

a)  La cláusula GROUP BY nos sirve para agrupar filas según las columnas que indique esta cláusula.

b)  La cláusula HAVING especifica condiciones de búsqueda para grupos de filas; lleva a cabo la misma función que antes cumplía la cláusula WHERE para las filas de toda la tabla, pero ahora las condiciones se aplican a los grupos obtenidos.

Presenta el siguiente formato:

SELECT nombre_columnas_a seleccionar
FROM tabla_a_consultar
[WHERE condiciones]
GROUP BY columnas_según_las_cuales_se_quiere_agrupar
[HAVING condiciones_por_grupos]
[ORDER BY columna_ordenación [DESC] [, columna [DESC]...]];

 

 

Factores de agrupación
Los factores de agrupación de la cláusula GROUP BY deben ser, como mínimo, las columnas que figuran en SELECT, exceptuando las columnas afectadas, por funciones de agregación.

Notemos que en las sentencias SQL se van añadiendo cláusulas a medida que la dificultad o la exigencia de la consulta lo requiere.

 

Consulta con agrupación de filas en BDUOC

 

Imaginemos que queremos saber el sueldo medio que ganan los empleados de cada departamento:

SELECT nombre_dep, ciudad_dep, AVG(sueldo) AS sueldo_medio
FROM empleados
GROUP BY nombre_dep, ciudad_dep;

El resultado de esta consulta sería:

nombre_dep ciudad_dep sueldo_dep
DIR Barcelona 90.000
DIR Girona 100.000
DIS Lleida 70.000
DIS Barcelona 70.000
PROD Tarragona 33.000
NULL NULL 40.000
num_proyec
4

Ejemplo de uso de la función de agregación SUM 

DISTINCT Y GROUP BY

En este ejemplo no es necesario poner DISTINCT, a pesar de que la columna num_proyec no es atributo identificador.
Fijémonos en que en la tabla empleados hemos puesto que todos los proyectos tienen el mismo código juntos en el mismo grupo y no es posible que aparezcan repetidos.

Veamos un ejemplo de uso de una función de agregación SUM del SQL que aparece en la cláusula HAVING de GROUP BY: “Queremos saber los códigos de los proyectos en los que la suma de los sueldos de los empleados es mayor que 180.000 euros”: 

 

 

 

 

 

 

 

 

SELECT num_proyec
FROM empleados
GROUP BY num_proyec
HAVING SUM (sueldo) &gt;1.8E+5;

El resultado de esta consulta sería el que se ve al margen.

2.5.6. Consultas de mas de una tabla

2.5.6. Consultas de mas de una tabla Dataprix 21 Septiembre, 2009 - 11:17

Muchas veces queremos consultar datos de más de una tabla haciendo combinaciones de columnas de tablas diferentes. En el SQL es posible listar más de una tabla que se quiere consultar especificándolo en la cláusula FROM.

1)  Combinación

Recordad que la misma operación de combinación, pero del álgebra relacional, se ha visto en el subapartado 5.3.3. de la unidad "El modelo relacional y el álgebra relacional"

La combinación consigue crear una sola tabla a partir de las tablas especificadas en la cláusula FROM, haciendo coincidir los valores de las columnas relacionadas de estas tablas.

Ejemplo de combinación en BDUOC

A continuación mostramos un ejemplo con la base de datos BDUOC en el que queremos saber el NIF del cliente y el código y el precio del proyecto que desarrollamos para el cliente número 20:

SELECT proyectos.codigo_proyecto, proyectos.precio, clientes.nif
FROM clientes, proyectos
WHERE clientes.codigo_cli = proyectos.codigo_cliente AND clientes.
codigo_cli = 20;

 El resultado sería:

proyectos.codigo_proyecto proyectos.precio clientes.nif
3 1.000.000 38.123.898-E

 

Si trabajamos con más de una tabla, puede ocurrir que la tabla resultante tenga dos columnas con el mismo nombre. Por ello es obligatorio especificar a qué tabla corresponden las columnas a las que nos estamos refiriendo, denominando la tabla a la que pertenecen antes de ponerlas (por ejemplo, clientes.codigo_cli). Para simplificarlo, se utilizan los alias que, en este caso, se definen en la cláusula FROM.

 

Ejemplo de alias en BDUOC

c podría ser el alias de la tabla clientes. De este modo, para indicar a qué tabla pertenece codigo_cli, sólo haría falta poner: c.codigo_cli.

Veamos cómo quedaría la consulta anterior expresada mediante alias, aunque en este ejemplo no serían necesarios, porque todas las columnas de las dos tablas tienen nombres diferentes. Pediremos, además, las columnas c.codigo_cli y p.codigo_cliente.

SELECT p.codigo_proyecto, p.precio, c.nif, p.codigo_cliente, c.codigo_cli
FROM clientes c, proyectos p
WHERE c.codigo_cli = p.codigo_cliente AND c.codigo_cli = 20;

 

Entonces obtendríamos este resultado:

p.codigo_proyec p.precio c.nif p.codigo_cliente c.codigo_cli
3 1.000.000 38.123.898-E 20 20

Notemos que en WHERE necesitamos expresar el vínculo que se establece entre las dos tablas, en este caso codigo_cli de clientes y codigo_cliente de proyectos. Expresado en operaciones del álgebra relacional, esto significa que hacemos una combinación en lugar de un producto cartesiano.

Las operaciones del álgebra relacional se han visto en el apartado 5 de la unidad "El modelo relacional y el álgebra relacional"

Fijémonos en que, al igual que en álgebra relacional, la operación que acabamos de hacer es una equicombinación (equi-join); por lo tanto, nos aparecen dos columnas idénticas: c.codigo_cli y p.codigo_cliente.

 

La forma de expresar la combinación que acabamos de ver pertenece al SQL92 introductorio. Una forma alternativa de realizar la equicombinación anterior, utilizando el SQL92 intermedio o completo, sería la siguiente:

SELECT nombre_columnas_a_seleccionar
FROM tabla1 JOIN tabla2
     {ON condiciones|USING (columna [, columna...])}
[WHERE condiciones];

 

Ejemplo anterior con el SQL92 intermedio o completo

El ejemplo que hemos expuesto antes utilizando el SQL92 intermedio o completo sería:

SELECT p.codigo_proyecto, p.precio, c.nif, p.codigo_cliente, c.codigo_cli
FROM clientes c JOIN proyectos p ON c.codigo_cli = p.codigo_cliente
WHERE c.codigo_cli = 20;

Y obtendríamos el mismo resultado de antes.

 

Pdemos ver la equicombinación y la Ø-combinación en el subapartado 5.3.3. de la unidad "El modelo relacional y el álgebra relacional"

La opción ON, además de expresar condiciones con la igualdad, en el caso de que las columnas que queramos vincular tengan nombres diferentes, nos ofrece la posibilidad de expresar condiciones con los demás operadores de comparación que no sean el de igualdad. Sería el equivalente a la operación que en álgebra relacional hemos denominado Ø-combinación (Ø-join).

 

También  podemos  utilizar  una  misma  tabla  dos  veces  con  alias  diferentes, para distinguirlas.

Dos alias para una misma tabla en BDUOC

Si pidiésemos los códigos y los apellidos de los empleados que ganan más que el empleado que tiene por código el número 5, haríamos lo siguiente:

SELECT p.codigo_proyecto, p.precio, c.nif, p.codigo_cliente, c.codigo_cli
FROM clientes c JOIN proyectos p ON c.codigo_cli = p.codigo_cliente
WHERE c.codigo_cli = 20;

 

Hemos tomado la tabla e2 para fijar la fila del empleado con código número 5, de modo que
podamos comparar el sueldo de la tabla e1, que contiene a todos los empleados, con el sueldo de la tabla e2, que contiene sólo al empleado 5.

La respuesta a esta consulta sería:

e1.codigo_empl e1.apellido_empl
1 Puig
2 Mas
3 Ros
4 Roca

 

2)  Combinación natural

La  combinación  natural  (natural  join)  de  dos  tablas  consiste  básicamente,  al igual que en el álgebra relacional, en hacer una equicombinación entre columnas del mismo nombre y eliminar las columnas repetidas. La combinación natural, utilizando el SQL92 intermedio o completo, se haría de la forma siguiente:

SELECT nombre_columnas_a_seleccionar
FROM tabla1 NATURAL JOIN tabla2
[WHERE condiciones];

 

Combinación natural en BDUOC

Veamos a continuación un ejemplo en el que las columnas para las que se haría la combinación natural se denominan igual en las dos tablas. Ahora queremos saber el código y el nombre de los empleados que están asignados al departamento cuyo teléfono es 977.33.38.52:

SELECT codigo_empl, nombre_empl
FROM empleados NATURAL JOIN departamentos
WHERE telefono = '977.333.852';

La combinación natural también se podría hacer con la cláusula USING, sólo aplicando la palabra reservada JOIN: 

SELECT codigo_empl, nombre_empl
FROM empleados JOIN departamentos USING (nombre_dep, ciudad_dep)
WHERE telefono = '977.333.852';

La respuesta que daría sería:

empleados.codigo_empl empleados.nombre_empl
5 Clara
6 Laura
8 Sergio

 

 
3)  Combinación interna y externa

Cualquier combinación puede ser interna o externa:

a)  La combinación interna (inner join) sólo se queda con las filas que tienen valores idénticos en las columnas de las tablas que compara. Esto puede hacer que perdamos alguna fila interesante de alguna de las dos tablas; por ejemplo, porque se encuentra a NULL en el momento de hacer la combinación. Su formato es el siguiente:

SELECT nombre_columnas_a_seleccionar
FROM t1 [NATURAL] [INNER] JOIN t2
       {ON condiciones|
       |USING(columna [,columna...])}
[WHERE condiciones];

 

b)  Por ello disponemos de la combinación externa (outer join), que nos permite obtener todos los valores de la tabla que hemos puesto a la derecha, los de la tabla que hemos puesto a la izquierda o todos los valores de las dos tablas. Su formato es:

SELECT nombre_columnas_a_seleccionar
FROM t1 [NATURAL] [LEFT|RIGHT|FULL] [OUTER] JOIN t2
       {ON condiciones|
       [USING (columna [,columna...])}
[WHERE condiciones];

 

Combinación natural interna en BDUOC

Combinación interna
Aunque en el ejemplo estamos haciendo una combinación natural interna, no es necesario poner la palabra INNER, ya que es la opción por defecto.

Si quisiéramos vincular con una combinación natural interna las tablas empleados y
departamentos para saber el código y el nombre de todos los empleados y el nombre, la ciudad y el teléfono de todos los departamentos, haríamos:

SELECT e.codigo_empl, e.nombre_empl, e.nombre_dep, e.ciudad_dep, d.telefono
FROM empleados e NATURAL JOIN departamentos d;

 Y obtendríamos el siguiente resultado:

e.codigo_empl e.nombre_empl e.nombre_dep e.ciudad_dep d.teléfono
1 María DIR Girona 972.23.89.70
2 Pedro DIR Barcelona 93.422.60.70
3 Ana DIS Lleida 973.23.50.40
4 Jorge DIS Barcelona 93.224.85.23
5 Clara PROG Tarragona 977.33.38.52
6 Laura PROG Tarragona 977.33.38.52
8 Sergio PROG Tarragona 977.33.38.52

 

 Fijémonos en que en el resultado no aparece el empleado número 7, que no está asignado a ningún departamento, ni el departamento de programación de Girona, que no tiene ningún empleado asignado.

Combinación natural externa a BDUOC

En los ejemplos siguientes veremos cómo varían los resultados que iremos obteniendo según los tipos de combinación externa:

a) Combinación externa izquierda

SELECT e.codigo_empl, e.nombre_empl, e.nombre_dep, e.ciudad_dep, d.telefono
FROM empleados e NATURAL LEFT OUTER JOIN departamentos d;
Combinación externa izquierda
Aquí fighura el empleado 7.

 El resultado sería el que podemos ver a continuación:

e.codigo_empl e.nombre_emple e.nombre_dep e.ciudad_dep d.telefono
 1  María DIR  Girona 972.23.89.70
 2  Pedro  DIR  Barcelona  93.422.60.70
 3  Ana  DIS  Lleida 973.23.50.40
 4  Jorge  DIS  Barcelona  93.224.85.23
 5  Clara  PROG  Tarragona  977.33.38.52
 6  Laura  PROG Tarragona  977.33.38.52
 7  Rogelio  NULL  NULL  NULL
 8 Sergio  PROG Tarragona  977.33.38.52

b) Combinación externa derecha

SELECT e.codigo_empl, e.nombre_empl, e.nombre_dep, e.ciudad_dep, d.telefono
FROM empleados e NATURAL RIGHT OUTER JOIN departamentos d;

 

Combinación externa derecha
Aquí figura el departamento de programación d

Obtendríamos este resultado:

e.codigo_empl e.nombre_emple e.nombre_dep e.ciudad_dep d.telefono
 1  María DIR  Girona 972.23.89.70
 2  Pedro  DIR  Barcelona  93.422.60.70
 3  Ana  DIS  Lleida 973.23.50.40
 4  Jorge  DIS  Barcelona  93.224.85.23
 5  Clara  PROG  Tarragona  977.33.38.52
 6  Laura  PROG Tarragona  977.33.38.52
 8 Sergio  PROG Tarragona  977.33.38.52
 NULL  NULL PROG  Girona 9272.23.50.91

c) Combinación externa plena

SELECT e.codigo_empl, e.nombre_empl, e.nombre_dep, e.ciudad_dep, d.telefono
FROM empleados e NATURAL FULL OUTER JOIN departamentos d;
Combinación externa plena
Aquí figura el empleado 7 y el departamento de programación de Girona.

Y obtendríamos el siguiente resultado:

e.codigo_empl e.nombre_emple e.nombre_dep e.ciudad_dep d.telefono
 4  Jorge  DIS  Barcelona  93.224.85.23
 5  Clara  PROG  Tarragona  977.33.38.52
 6  Laura  PROG Tarragona  977.33.38.52
 7  Rogelio  NULL  NULL  NULL
 8 Sergio  PROG Tarragona  977.33.38.52
 NULL  NULL PROG  Girona 9272.23.50.91

 

4)  Combinaciones con más de dos tablas

Si queremos combinar tres tablas o más con el SQL92 introductorio, sólo tenemos que añadir todas las tablas en el FROM y los vínculos necesarios en el WHERE. Si queremos combinarlas con el SQL92 intermedio o con el completo, tenemos que ir haciendo combinaciones de tablas por pares, y la tabla resultante se convertirá en el primer componente del siguiente par. 

Combinaciones con más de dos tablas en BDUOC

Veamos ejemplos de los dos casos, suponiendo que queremos combinar las tablas empleados, proyectos y clientes:

SELECT *
FROM empleados, proyectos, clientes
WHERE num_proyec = codigo_proyec AND codigo_cliente = codigo_cli;

o bien:

SELECT *
FROM (empleados JOIN proyectos ON num_proyec = codigo_proyec)
JOIN clientes ON codigo_cliente = codigo_cli;

2.5.7. La union

2.5.7. La union Dataprix 22 Septiembre, 2009 - 10:19

La cláusula UNION permite unir consultas de  dos o más sentencias SELECT FROM. Su formato es:

SELECT columnas
FROM tabla
[WHERE condiciones]
UNION [ALL]
SELECT columnas
FROM tabla
[WHERE condiciones];

 

ciudad
Barcelona
Girona
Lleida
Tarragona

Si ponemos la opción ALL, aparecerán todas las filas obtenidas a causa de la unión. No la pondremos si queremos eliminar las filas repetidas. Lo más importante de la unión es que somos nosotros quienes tenemos que procurar que se efectúe entre columnas definidas sobre dominios compatibles; es decir, que tengan la misma interpretación semántica. Como ya hemos comentado, el SQL92 no nos ofrece herramientas para asegurar la compatibilidad semántica entre columnas.

Utilización de la unión en BDUOC

Si queremos saber todas las ciudades que hay en nuestra base de datos, podríamos hacer:

SELECT ciudad
FROM clientes
UNION
SELECT ciudad_dep
FROM departamentos;

El resultado de esta consulta sería el que se muestra al margen.

 

2.5.8. La Intersercion

2.5.8. La Intersercion Dataprix 22 Septiembre, 2009 - 10:27

Para hacer la intersección entre dos o más sentencias SELECT FROM, podemos utilizar la cláusula INTERSECT, cuyo formato es

SELECT columnas
FROM tabla
[WHERE condiciones]
INTERSECT [ALL]
SELECT columnas
FROM tabla
[WHERE condiciones];

Si indicamos la opción ALL, aparecerán todas las filas obtenidas a partir de la intersección. No la pondremos si queremos eliminar las filas repetidas.

Lo más importante de la intersección es que somos nosotros quienes tenemos que vigilar que se haga entre columnas definidas sobre dominios compatibles; es decir, que tengan la misma interpretación semántica.

Utilización de la intersección en BDUOC

ciudad
Barcelona
Girona
Lleida
Tarragona

Si queremos saber todas las ciudades donde tenemos departamentos en los que podamos encontrar algún cliente, podríamos hacer:

 

 

 

SELECT ciudad

FROM clientes
INTERSECT
SELECT ciudad_dep
FROM departamentos;

El resultado de esta consulta sería el que se muestra al margen.

Sin embargo, la intersección es una de las operaciones del SQL que se puede hacer de más formas diferentes. También podríamos encontrar la intersección con IN o EXISTS:

a)  Intersección utilizando IN

SELECT columnas
FROM tabla
WHERE columna IN (SELECT columna
                  FROM tabla
                  [WHERE condiciones]);

b)  Intersección utilizando EXISTS

SELECT columnas
FROM tabla
WHERE EXISTS (SELECT *
              FROM tabla
              WHERE condiciones);

El ejemplo que hemos propuesto antes se podría expresar con IN:

SELECT c.ciudad
FROM clientes c
WHERE c.ciudad IN (SELECT d.ciudad_dep
                   FROM departamentos d);

o también con EXISTS:

SELECT c.ciudad
FROM clientes c
WHERE EXISTS (SELECT *
              FROM departamentos d
              WHERE c.ciudad = d.ciudad_dep;

2.5.9. La diferencia

2.5.9. La diferencia Dataprix 22 Septiembre, 2009 - 10:30

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

SELECT columnas
FROM tabla
[WHERE condiciones]
EXCEPT [ALL]
SELECT columnas
FROM tabla
[WHERE condiciones];

Si ponemos la opción ALL aparecerán todas las filas que da la diferencia. No la pondremos si queremos eliminar las filas repetidas.

Lo más importante de la diferencia es que somos nosotros quienes tenemos que vigilar que se haga entre columnas definidas sobre dominios compatibles.

Utilización de la diferencia en BDUOC

codigo_cli
40

Si queremos saber los clientes que no nos han contratado ningún proyecto, podríamos hacer:

SELECT codigo_cli
FROM clientes
EXCEPT
SELECT codigo_cliente
FROM proyectos;

El resultado de esta consulta sería el cliente con código 40.

La diferencia es, junto con la intersección, una de las operaciones del SQL que se puede realizar de más formas diferentes. También podríamos encontrar la diferencia utilizando NOT IN o NOT EXISTS:

a)  Diferencia utilizando NOT IN:

SELECT columnas
FROM tabla
WHERE columna NOT IN (SELECT columna
                      FROM tabla
                      [WHERE condiciones]);

b)  Diferencia utilizando NOT EXISTS:

SELECT columnas
FROM tabla
WHERE NOT EXISTS (SELECT *
                  FROM tabla
                  WHERE condiciones);

Ejemplo anterior expresado con NOT IN y con NOT EXISTS

El ejemplo que hemos hecho antes se podría expresar con NOT IN:

SELECT c.codigo_cli
FROM clientes c
WHERE c.codigo_cli NOT IN (SELECT p.codigo_cliente
                           FROM proyectos p);

o también con NOT EXISTS

SELECT c.codigo_cli
FROM clientes c
WHERE NOT EXISTS (SELECT *
                  FROM proyectos p
                  WHERE c.codigo_cli = p.codigo_cliente);