BASES DE DATOS.- TERCERA EVALUACIÓN SQL inner join con más de dos tablas select e.nombrep “nombre empleado”, horas, p.nombrep “nombre proyecto” from empleado e inner join trabaja_ent on e.nss=t.nss inner join proyecto p on p.numerop=t.nump;
nombre empleado
HORAS
nombre proyecto
José Silva
7,5
Producto Y
José Silva
32,5
Producto X
A partir de Oracle 10g se puede poner también:
Reunión externa por la izquierda select nombrep, nump, horas from empleado e left outer join trabaja tr abaja t on e.nss=t.nss;
Reunión externa por la derecha select nombrep,nump, horas from empleado e right outer join trabaja t on e.nss=t.nss;
Reunión externa completa: select nombrep, nump, horas from empleados,trabaja
where empleados.nss(+)=trabaja.n empleados.nss(+)=trabaja.nss ss unión….
Resumen -
-
-
En una consulta multitabla, las tablas que contienen los datos son designadas en la cláusula FROM. Cada fila de resultados es una combinación c ombinación de datos procedentes de una única fila en cada una de las tablas, y es la única fila que extrae sus datos de esa combinación particular. Las consultas multitabla más habituales utilizan las relaciones padre/hijo creadas por las claves primarias y claves ajenas. En general, las composiciones pueden construirse comparando cualquier par(es) de columnas de dos tablas compuestas, utilizan un test de desigualdad o cualquier otro test de comparación. Una composición puede ser considerada como un producto de dos tablas del cual se han suprimido alguna de las filas. Una tabla puede componerse consigo misma; las autocomposiciones de dos tablas requieren el uso de alias. Las composiciones externas amplían la composición estándar (interna) reteniendo las filas con emparejadas de las tablas compuestas en los resultados de la consulta.
Funciones de agregación (consultas resumen). SUM AVG MIN MAX COUNT COUNT(*) STDDV VARIANCE
Valores nulos: Los valores NULL son ignorados por las funciones de columna y esto puedo afectar en funciones como AVG, SUM, COUNT. Para hacer que un NULL tome el valor cero para esa expresión se utiliza la función NVL (campo, valor_a_tomar). Ver la diferencia entre: select AVG(horas) from trabaja_en y select AVG(NVL(horas,0))
from trabaja_en
Reglas para los valores nulos: Si alguno de los valores de datos de una columna es NULL, se ignora para el propósito de calcular el valor de la función de columna. Si todos los datos de una columna son NULL, las funciones de columna SUM(), AVG(), MAX() y MIN() devuelven un valor NULL; la función COUNT devuelve un valor cero. Si no hay datos en la columna (es decir, la columna está vacía), las funciones de columna SUM(),AVG(), MAX()0 y MIN() devuelven un valor cero. La función COUNT(*) cuenta filas, y no depende de la presencia o ausencia de valores NULL en la columna. Si no hay filas devuelve un valor de cero. -
No es lo mismo select conunt(*) from trabaja_en que select count (horas) from trabaja_ en.
Cálculo total de una columna (SUM)
Horas totales trabajadas en todos los proyectos select SUM (horas) horas_totales from trabaja_en; Resultado: HORAS_TOTALES 275 Calcular la media de las horas que se han realizado. select avg(horas) from trabaja_en; Resultado: 18,33333333333333333333333333333333333333333333333 select round(avg(horas),2) Dos decimales from trabaja_en; Resultado: 18,33 Esta media estaría mal ya que hay un señor que no me lo cuenta. Solución: select avg(nvl(horas,0)),2) Al que no contaba,le cuento que ha echado 0 horas. from trabaja_en; Resultado: 17,19 He contado uno más porque no hecha horas, le asigno el 0.
Para saber las filas que tiene ese campo: select count(*) from trabaja_en; Resultado:16
Si pongo: select count(horas) from trabaja_en; Resultado:15 porque el nulo no me lo cuenta
select min(horas) cual es la cantidad de horas que menos se ha echado from trabaja_en; Resultado: 5 eso no es verdad, hay un valor nulo
select min(nvl(horas),0)) from trabaja_en; Resultado:0 ahora si está bien
Consultas agrupadas: (GROUP BY)
A veces queremos ver los resultados anteriores agrupados por algún concepto, por ejemplo las horas trabajadas por cada uno de los trabajadores, o el número de trabajadores en cada proyecto, para ello utilizamos la cláusula GROUP BY. Es una forma de resumir los resultados en subtotales. Ejemplo: número de trabajadores en cada proyecto select nump “nºproyecto”, count (nump) “nº trabajadores” from trabaja_en GROUP BY nump; Nºproyecto nºtrabajadores 1 2 3 10 20 30
2 3 2 3 3 3
Para sacar el número de horas: select nump, sum(horas) from trabaja_ en group by nump; Resultado: 30 55 2 37,5 20 25 3 50 10 55 Solución más correcta: select nump, sum(nvl(horas,0)) from trabaja_en group by nump;
Por número de proyecto, ascendentemente: select nump, sum(nvl(horas,0)) from trabaja_en group by nump order by 1; (como por defecto es ascendente no hay que ponerlo) Sacar las horas que echan en el proyecto:
select nump, count(horas) cuenta las entradas que hay de cada proyecto que tengan valor from trabaja_en group by nump order by 1; Resultado: NUMP 1 2 3 10 20 30
COUNT(HORAS) 2 3 2 3 2 3
select nump, count(*) cuenta el número de filas que hay de cada proyecto from trabaja_en group by nump order by 1;
Ahora en el 20 salen 3, ya hay un valor que a pesar de nulo, lo cuenta.
Media de horas en el número de proyectos: select nump “nº de proyecto”,avg(nvl(horas,0)) “media de horas” de esta manera cuenta el cero, mejor ponerlo from trabaja_en group by nump order by 1;
Múltiples columnas de agrupación: Relación de horas totales en cada proyecto ordenado por el número de horas
select nombrep, nump, sum(horas) from trabaja_en, proyecto where nump=numerop group by nombrep,nump order by sum(horas)desc;
NOMBREP
NUMP
SUM(HORAS)
Automatización
10
55
Nuevas prestaciones
30
55
Producto X
1
52,5
Producto Y Producto Z
Proyecto que menos horas hecha: No podemos sacarlo con lo que sabemos, porque el máximo y el mínimo son resultados de una tabla de un mismo valor, no puede haber más campos. select nump, min(sum(horas)) from trabaja_en group by nump; Esto da error, no es un grupo simple. select nump from trabaja_en having sum(horas)=(select min(horas)FROM trabaja_en group by nump)
group by nump; (más adelante) 02-04-2014 REPASO GROUP BY select nombrep,e.nss, sum (nvl(horas,0)) from empleado e, trabaja_en t where e.nss=t.nss group by nombrep,e.nss; todos los campos no calculados del select tiene que ir en el group by
Nombre del proyecto, número de proyecto y horas totales que se echan en cada uno de los proyectos.
select nombrep“nombre del proyecto”, numerop“numero del proyecto”, sum(nvl(horas,0))“horas” from trabaja_en t, proyecto p where t.nump=p.numerop group by nombrep,numerop;
Proyectos en los que se trabaje más de 40 horas.
select nombrep“nombre del proyecto”, numerop“numero del proyecto”, sum(nvl(horas,0))“horas” from trabaja_en t, proyecto p where t.nump=p.numerop having sum(nvl(horas,0))>40 group by nombrep,numerop; Sin agrupar: select nombrep, numerop,horas from proyecto p, trabaja_ en t where numerop=nump
(En donde más de 20 horas: agrupado pero sin sumar ) select nombrep, numerop,horas from proyecto p, trabaja_ en t where numerop=nump and horas>20
SQL Restricciones en consultas agrupadas:
1.- Las columnas de agrupación deben ser columnas efectivas de las tablas designadas en la claúsula FROM de la consulta. No se pueden agrupar filas basándose en el valor de una expresión calculada. 2.-Todos los elementos de las listas de selección debe tener un único valor por grupo de filas, esto quiere decir que un elemento de selección en una consulta agrupada debe ser: a) Una constante b) Una función de columna, que produce un único valor que resume filas del grupo. c) Una columna de agrupación, que por definición tiene el mismo valor en todas las filas del grupo, o d) Una expresión que afecte a combinaciones de los anteriores. Si no aparece una función de columna, la columna puede expresarse más sencillamente utilizando SELECT DISTINCT, sin GROUP BY Valores nulos en columnas de agrupación (group by):
El estándar SQL/ANSI considera que dos valores NULL son iguales a efectos de la claúsula GROUP BY. Si dos filas tienen NULL en las mismas columnas de agrupación y valores idénticos en las columnas de agrupación no NULL, se agrupan dentro del mismo grupo de filas. Ejemplo: select pelo, ojos, count (*) from personas group by pelo, ojos;
Condiciones de búsqueda de groups: (HAVING)
La cláusula HAVING se utiliza para seleccionar o rechazar grupos de filas. Especifica una condición de búsqueda para grupos. El formato de la cláusula HAVING, es análogo al de la cláusula WHERE, consistiendo en la palabra clave HAVING seguida de una condición de búsqueda. Restricciones en condiciones de búsqueda de grupos:
-
Un elemento que aparezca dentro de la condición de búsqueda en una cláusula HAVING puede ser: Una constante o Una función de columna, que produzca un único valor resumen de las filas del o grupo, Una columna de agrupación que por definición tiene el mismo valor para todas o las filas del grupo, Una expresión que afecte a combinaciones de las anteriores. o
-
La cláusula WHERE se aplica a filas individuales por lo que las expresiones que contiene deben ser calculables para filas individuales. La cláusula HAVING se aplica a grupos de filas, por lo que las expresiones que contengan deben ser calculables para un grupo de filas. Si la condición de búsqueda es NULL, el grupo de filas se descarta y no contribuye con una fila resumen a los resultados de la consulta. Si la cláusula HAVING aparece sin GROUP BY, SQL considera el conjunto entero de resultados detallados como un único grupo. El uso de la cláusula HAVING si la correspondiente cláusula GROUP BY casi nunca se ve en la práctica.
-
select sum(horas) from trabaja_en, proyecto where nump=numerop having sum(horas)>30 order by sum (horas)desc; Resultado: SUM (HORAS)
275
Mínimo de horas que se trabaja por empleado (por persona no por proyecto)
select min(sum(nvl(horas,0))) from trabaja_en group by nss; Resultado: 0
Si no cuenta el nulo: select min(sum (horas)) from trabaja_en group by nss; Resultado: 35
Agrupados por nss: por una parte el mínimo de horas en conjunto(cero horas) y por otra parte he sacado quien trabaja cero horas.
(Subselect) select nss,sum(nvl(horas,0)) from trabaja_en group by nss having sum(nvl(horas,0))=(select min(sum(nvl,horas,0))) from trabaja_en group by nss);
Media de las horas trabajadas en el proyecto de reorganización.
select round(avg(nvl(horas,0)),2) from proyecto p, trabaja_en t where nump=p.numerop and upper(nombrep)=‘REORGANIZACIÓN’; Otra forma:
select nump,nombrep,avg(nvl(horas,0)) from trabaja_en, proyecto where nump=numerop and nombrep=‘Reorganización’ group by nombrep;
IMPORTANTISIMO EL NVL!!!!
Fecha de nacimiento del empleado mayor select min(fechanac) from empleado; Resultado: min(fechanac) : 10/11/27 (el más viejo)
Para que salgan los nombres de los nacidos a partir de 1950: select nombrep from empleado where to_char(fechanac, ‘yyyy’)>’1950’;
El más Viejo: con subselect select nombrep from empleado where fechanac=(select min(fechanac) from empleado); http://www.lsi.us.es/docencia/get.php?id=3189 ejercicio sevilla
Relación de proyectos(nombre, número de proyecto) y número de empleados que trabaja en cada uno de ellos. select nombrep,nump,count(nss)
from proyecto p,trabaja_en t where nump=numerop group by nombrep, nump order by nombrep;
Número y nombre de proyectos en los que se trabaje más de 45 horas.
select nombrep”Nombre proyecto”, numerop”Numero proyecto”, sum(nvl(horas,0))”Horas” from trabaja_en t, proyecto p where t.nump=p.numerop having sum(nvl(horas,0)) > 45 group by nombrep,numerop;
Sacar el nombre de los trabajadores que trabajan de media más de 30 horas.
select nombrep,avg(nvl(horas,0)) from trabaja_en t, empleado e where t.nss=e.nss group by nombrep having avg(nvl(horas,0))>30 order by nombrep;
SQL : SUBCONSULTAS
(select all/distinct elemento de selección from especificación de tabla where condición de búsqueda group by columna de agrupación having condición de búsqueda)
select e.nombrep, e.nss from empleado e, trabaja_en t
where e.nss=t.nss group by nombrep,e.nss having sum(nvl(horas,0))=(select min (nvl(sum(horas),0)) from trabaja_en group by nss); Una subconsulta es una sentencia SELECT que aparece dentro de otra sentencia SELECT que llamaremos consulta principal. Se puede encontrar en la lista de selección, en la cláusula WHERE o en la cláusula HAVING de la ocnsulta principal. Una subconsulta va siempre entre paréntesis. Una subconsulta debe producir una única columna de datos como resultado. Esto significa que una subconsulta siempre tiene un único elemento de selección en su cláusula SELECT. La cláusula ORDER BY no puede ser especificada en una subconsulta. Una subconsulta no puede ser la UNIÓN de varias sentencias SELECT diferentes; solo se permite una única sentencia SELECT. Los nombres de columna que aparecen en una subconsulta pueden referirse a columnas de tablas de la consulta principal, esto es lo que se conoce como referencias externas. Subconsultas en la cláusula WHERE Las subconsultas suelen ser utilizadas principalmente en la cláusula WHERE de una sentencia SQL. Cuando aparece una subconsulta en la cláusula WHERE ésta funciona como parte del proceso de selección de filas. ejemplo: empleado que más gana:
Sacar el empleado que más gana
select nombrep, salario from empleado where salario=(select max(salario) from empleado); Referencias externas: Dentro del cuerpo de una subconsulta, con frecuencia es necesario referirse al valor de una columna en la fila actual de la consulta principal. ejemplo: en la base de datos LIBRO Listar las oficinas (ciudades) en donde el objetivo de ventas de la oficina excede a la suma de las cuotas de los vendedores individuales. select ciudad from oficinas
where objetivo > (select sum(cuota) from repventas where oficina_rep=oficina);
Observamos que en el segundo WHERE se compara con una columna de una tabla especificada en el FROM de la consulta principal. Test de comparación subconsulta: (=,<>,!=,^=,<,<=,>,>=) Ejemplo: Nombre y salario del empleado que es gerente del departamento Investigación. select nombrep,salario from empleado where nss=(select nss from departamento where nombred=’Investigacion’);
Personal perteneciente (nombre) al departamento de Investigación. select nombrep from empleado where nd=(select numerod from departamento where upper(nombred)=’INVESTIGACIÓN’);
Suponiendo que las horas se paguen a 10 euros, sacar el nombre y el departamento de los empleados que tengan un salario menor que la suma de todas las horas por su precio.
select nombrep,nd,salario from empleado where salario<(select sum(horas)*10 from trabaja_en); Con el nombre de departamento: select nombrep,nd,salario,nombred from empleado, departamento where salario<(select sum(horas)*10 from trabaja_en) and nd=numerod; Sacar nombre,nº de la SS y salario del empleado de mayor sueldo: select nombrep,nss,salario
from empleado where salario=(select max(salario) from empleado); Test de pertenencia (o no) a un grupo (in): Ejemplo: Nombre y salario de los empleados gerentes de los departamentos. select nombrep,salario from empleado where nss in(select nss from departamento);
Saca los empleados que tengan algún dependiente: select nombrep,nss from empleado where nss in(select distinct(nss) from dependiente); Saca los empleados que no tengan ningún dependiente: select nombrep,nss from empleado where nss not in(select distinct(nss) from dependiente); Relación de empleados que no dirigen ningún departamento: select nombrep,salario from empleado where nss not in(select nss from departamento);
Test de existencia (EXISTS):
El test de existencia comprueba si la subconsulta produce alguna fila de resultados. Ejemplo: Relación de los empleados del departamento de investigación: select nombrep, salario from empleado where exists(select* from departamento where nd=numerod and nombred=’Investigación’);
Otra forma de hacerlo: select nombrep,salario from empleado,departamento where nd=numerod and upper(nombred)=’INVESTIGACIÓN’;
Otra forma: select nombrep,salario from empleado where nd=(select numerod from departamento where nombred=’Investigación’);
Relación entre la resta minus, not in y not exists Supongamos de la base de datos ejemplo La siguiente cuestión: Obtener los códigos de los proyectos suministrados únicamente por S1 (ejemplo Sevilla).
select spj1.j from spj spj1 (lo renombro para que no haya ambigüedades) where spj1.s= ‘S1’ minus select spj2.j from spj spj2 (lo renombro para que no haya ambigüedades) where spj2.s != ‘S1’; o where spj2.s<>’S1’;
Otra forma:
select distinct spj1.j from spj spj1 where not exists(select* from spj spj2 where spj1.j=spj2.j and spj2.s!=’S1’); Otra más:
select distinct spj1.j
from spj spj1 where spj.j not in (select spj2.j from spj spj2 where spj.s != ‘S1’;
Obtener los códigos de los proyectos no suministrados por S1.
select distinct spj2.j from spj spj2 where spj2.s!='S1';
División: r/s (palabra clave TODAS) Relación de clientes que tienen cuenta en TODAS las sucursales de Albacete: En SQL se puede poner como:
r la tabla donde va sucursales y clientes (que tienen cuenta en todas las sucursales de Albacete). s son las sucursales de albacete, A son las sucursales y B son los clientes. select distinct r1.B from r r1 where not exists (select * from s where not exists (select* from r r2 where r2.B=r1.B and s.A=r2.A));
Ejemplo: Relación de empleados que trabajan en todos los proyectos: Primero haremos la división entre trabaja_en y proyecto:
select distinct t.nss from trabaja_en t where not exists(select * from proyecto p where not exists (select * from trabaja_en t2 where t2.nump=p.numerop and t2.nss=t.nss));
Con esto sacamos todos los nss que trabajan en todos los proyectos y a partir de aquí podremos sacar los nombres de estos empleados: select nombrep from empleados where empleados.nss in(… Test cuantificados (ALL y ANY):
IN comprueba si un valor de datos es igual a algún valor en una columna de los resultados de la subconsulta. SQL proporciona dos test cuantificados, ANY y ALL, que extienden esta noción a otros operadores de comparación como > y <. Ambos tests comparan un valor de dato con la columna de valores producidos por una subconsulta. Test ANY Se utiliza conjuntamente con uno de los seis operadores de SQL(=…) para comparar un único valor de test con una columna de valores producidos por una subconsulta. Para efectuar el test SQL, utiliza el operador de comparación especificado para comparar un valor de test con cada valor de datos de la columna, uno cada vez. Si alguna de las comparaciones individuales producen un resultado verdadero, el test ANY devuelve un resultado verdadero. Ejemplo: Listar las oficinas y sus objetivos, en donde alguno de sus empleados tienen ventas que superan el 50% del objetivo de la oficina. select ciudad, objetivo from oficinas where (.50* objetivo)
Otro ejemplo: Oficinas cuyo objetivo sea superior a alguna de las sumas de las cuotas obtenidas. select oficina, ciudad from oficinas where objetivo> ANY (select sum(cuota) from repventas group by oficina_rep);
Oficinas cuyo objetivo sea superior a alguna de las sumas obtenidas. Si se entiende como ventas: select oficina, ciudad from oficinas where objetivo> ANY (select sum(ventas) from repventas group by oficina_rep);
Mayor que todas las ventas: select oficina, ciudad from oficinas where objetivo> all (select sum(ventas) from repventas group by oficina_rep);
Mayor que todas las cuotas: select oficina, ciudad from oficinas where objetivo> all (select sum(cuota) from repventas group by oficina_rep);
Es equivalente: (asi hallaríamos el valor mayor para luego comparar) select max(sum(ventas)) from repventas group by oficina_rep;
El any y el some son equivalentes. Si buscáramos la menor de todas: select oficina, ciudad from oficinas where objetivo< all (select sum(ventas) from repventas group by oficina_rep);
Test ALL Se utiliza también con uno de los seis operadores de comparación de SQL(=,>…) para comparar un único valor de test con una columna de valores de datos producidos por un subconsulta. Para efectuar el test, SQL utiliza el operador de comparación especificado para comparar el valor de test con todos y cada uno de los valores de datos de la columna. Si todas las comparaciones individuales producen un resultado VERDADERO, el test ALL devuelve un resultado VERDADERO. El empleado cuyo salario sea mayor que lo que cobre alguno echando horas. select nombrep from empleado where salario any > (select max(salario) from empleado);
Subconsultas y comparaciones: Hay veces que una consulta puede realizarse como consulta multitable o bien como composiciones de subconsultas. Ejemplo. Sacar los nombres, salario, nº de departamento de los empleados del departamento de investigación. select nombrep, salario, nd from empleado where nd=(select numerod from departamento where nombred=’Investigación’);
Si me piden también el nombre de departamento: select nombrep,salario,(select nombred from departamento where nombred='Investigación')departamento from empleado where nd=(select numerod from departamento where nombred='Investigación');
Sin subselect: select nombrep,salario,nd from empleado, departamento where nd=numerod and nombred=’Investigación’;
Si me piden también el nombre de departamento: select nombrep,salario,nombred from empleado, departamento where nd=numerod and nombred='Investigación';
Subconsultas usadas en cualquier lugar de una expresión: Una subconsulta se puede usar allí donde se pueda usar una expresión en las instrucciones SELECT, UPDATE, INSERT y DELETE, excepto en una lista ORDER BY. Ejemplos: -Importe de los productos del fabricante ACI, el importe medio de todos los productos y la diferencia entre el importe del producto y el precio promedio de todos los productos: - Importe de los productos del fabricante ACI, el importe medio de todos sus productos y la diferencia entre el importe del producto y precio promedio de todos sus productos. 1.- select producto, importe,(select round(avg(importe),2)from pedidos) MEDIA, importe-(select round(avg(precio),2)from productos)as Diferencia from pedidos where fab='ACI';
2.- select producto, importe,(select round(avg(importe),2) from pedidos WHER E FAB='ACI')MEDIA, importe-(select round(avg(precio),2)from productos WHERE FAB='ACI') DIFERENCIA from pedidos where fab='ACI';
Subconsultas anidadas: Empleados que trabajan el proyecto de Automatización: select nombrep from empleado where nss in(select nss from trabaja_en where nump in(select numerop from proyecto where nombrep=’Automatización’);
Subconsultas correlacionadas: Una subconsulta correlacionada es una subconsulta que contiene una referencia a una tabla que también aparece en la consulta exterior. En una subconsulta correlacionada, las consultas principales y subordinadas extraen datos de la misma tabla.
Subconsultas en la cláusula HAVING: Aunque las subconsultas suelen encontrarse sobre todo en la cláusula WHERE, también pueden utilizarse en la cláusula HAVING. Cuando aparece en este cláusula, funciona como parte de la selección de grupo de las filas efectuadas por la cláusula HAVING. Ejemplo: Seleccionar el nombre, salario, nss y horas del trabajador que más horas ha realizado. select nombrep, salario, empleado.nss, sum(horas) from empleado, trabaja_en where empleado.nss=trabaja_en.nss group by nombrep, salario, empleado.nss having sum(horas)=(select max(sum(horas)) from trabaja_en group by trabaja_en.nss);
Alternativa: select nombrep,nss, salario from empleado where nss in(select nss from trabaja_en
group by nss having sum(horas)=(select max(sum(horas)) from trabaja_en group by nss));
El que menos horas realiza: select nombrep, salario, empleado.nss, s um(nvl(horas,0))horas from empleado, trabaja_en where empleado.nss=trabaja_en.nss group by nombrep, salario, empleado.nss having sum(horas)=(select min(sum(horas)) from trabaja_en group by trabaja_en.nss);
Resumen: 1. Una subconsulta es una consulta dentro de una consulta, que aparecen dentro de where o having. 2. Cuando aparece una subconsulta en la cláusula where, los resultados de la subconsulta se utilizan para seleccionra las filas individuales que contribuyen a los datos de los resultados de la consulta. 3. Cuando una subconsulta aparece en la cláusula having, los resultados de la subconsulta se utilizar para seleccionar los grupos… 4. 5. La forma subconsulta del test de comparación utiliza uno de los operadores de comparación simple para comparar un valor de todos con el valor único devuelto por una subconsulta. 6. La forma subconsulta del test de pertenencia a conjunto (in) compara el valor de test con el conjunto de valores devuelto por una subconsulta. 7. El test de existencia (exists) comprueba si una subconsulta devuelve algún valor. 8. Los test cuantificados (any y all) utilizan uno de los operadores de comparación simple para comparar un valor de test con todos los valores devueltos con una subconsulta, comprobando si la comparación resuelta cierta para alguno de los valores o para todos. 9. Una subconsulta puede incluir una referencia externa a una tabla de cualquiera de las consultas que la contienen, enlazando la subconsulta con la fila “actual” de esa consulta.
Seleccionar el nombre y el nº de los empleados cuya fecha de contrato sea igual a la primera fecha de todos los pedidos de la empresa.
select nombre,num_empl from repventas where contrato=(select min(fecha_pedido)from pedidos);
