BASES DE DATOS.

- TERCERA EVALUACIN
SQL
inner join con ms 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 tambin:

Reunin externa por la izquierda
select nombrep, nump, horas
from empleado e left outer join trabaja t
on e.nss=t.nss;

Reunin externa por la derecha
select nombrep,nump, horas
from empleado e right outer join trabaja t
on e.nss=t.nss;

Reunin externa completa:
select nombrep, nump, horas
from empleados,trabaja
where empleados.nss(+)=trabaja.nss
unin.

Resumen
- En una consulta multitabla, las tablas que contienen los datos son designadas en la
clusula FROM.
- Cada fila de resultados es una combinacin de datos procedentes de una nica fila en
cada una de las tablas, y es la nica fila que extrae sus datos de esa combinacin
particular.
- Las consultas multitabla ms 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 comparacin.
- Una composicin 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 amplan la composicin estndar (interna) reteniendo las
filas con emparejadas de las tablas compuestas en los resultados de la consulta.
Funciones de agregacin (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 expresin se utiliza la funcin 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 propsito de
calcular el valor de la funcin 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 funcin COUNT devuelve un valor cero.
Si no hay datos en la columna (es decir, la columna est vaca), las funciones de columna
SUM(),AVG(), MAX()0 y MIN() devuelven un valor cero.
La funcin 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.
Clculo 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 estara mal ya que hay un seor que no me lo cuenta. Solucin:
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 ms 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 algn concepto, por ejemplo las
horas trabajadas por cada uno de los trabajadores, o el nmero de trabajadores en cada
proyecto, para ello utilizamos la clusula GROUP BY. Es una forma de resumir los resultados en
subtotales.
Ejemplo:
nmero de trabajadores en cada proyecto
select nump nproyecto, count (nump) n trabajadores
from trabaja_en
GROUP BY nump;
Nproyecto ntrabajadores
1 2
2 3
3 2
10 3
20 3
30 3


Para sacar el nmero de horas:
select nump, sum(horas)
from trabaja_ en
group by nump;

Resultado:
30 55
2 37,5
20 25
3 50
10 55
Solucin ms correcta:
select nump, sum(nvl(horas,0))
from trabaja_en
group by nump;


Por nmero 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 COUNT(HORAS)
1 2
2 3
3 2
10 3
20 2
30 3

select nump, count(*) cuenta el nmero 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 nmero 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;

Mltiples columnas de agrupacin:
Relacin de horas totales en cada proyecto ordenado por el nmero 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)
Automatizacin 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 mximo y el mnimo son resultados de una
tabla de un mismo valor, no puede haber ms 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;
(ms 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, nmero de proyecto y horas totales que se echan en cada uno
de los proyectos.
select nombrepnombre del proyecto, numeropnumero 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 ms de 40 horas.

select nombrepnombre del proyecto, numeropnumero 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 ms 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 agrupacin deben ser columnas efectivas de las tablas designadas en la
clasula FROM de la consulta. No se pueden agrupar filas basndose en el valor de una
expresin calculada.
2.-Todos los elementos de las listas de seleccin debe tener un nico valor por grupo de filas,
esto quiere decir que un elemento de seleccin en una consulta agrupada debe ser:
a) Una constante
b) Una funcin de columna, que produce un nico valor que resume filas del grupo.
c) Una columna de agrupacin, que por definicin tiene el mismo valor en todas las filas del
grupo, o
d) Una expresin que afecte a combinaciones de los anteriores.
Si no aparece una funcin de columna, la columna puede expresarse ms sencillamente
utilizando SELECT DISTINCT, sin GROUP BY
Valores nulos en columnas de agrupacin (group by):
El estndar SQL/ANSI considera que dos valores NULL son iguales a efectos de la clasula
GROUP BY. Si dos filas tienen NULL en las mismas columnas de agrupacin y valores idnticos
en las columnas de agrupacin no NULL, se agrupan dentro del mismo grupo de filas.
Ejemplo:
select pelo, ojos, count (*)
from personas
group by pelo, ojos;

Condiciones de bsqueda de groups: (HAVING)
La clusula HAVING se utiliza para seleccionar o rechazar grupos de filas. Especifica una
condicin de bsqueda para grupos.
El formato de la clusula HAVING, es anlogo al de la clusula WHERE, consistiendo en la
palabra clave HAVING seguida de una condicin de bsqueda.
Restricciones en condiciones de bsqueda de grupos:
- Un elemento que aparezca dentro de la condicin de bsqueda en una clusula
HAVING puede ser:
o Una constante
o Una funcin de columna, que produzca un nico valor resumen de las filas del
grupo,
o Una columna de agrupacin que por definicin tiene el mismo valor para todas
las filas del grupo,
o Una expresin que afecte a combinaciones de las anteriores.
- La clusula WHERE se aplica a filas individuales por lo que las expresiones que contiene
deben ser calculables para filas individuales.
- La clusula HAVING se aplica a grupos de filas, por lo que las expresiones que
contengan deben ser calculables para un grupo de filas.
- Si la condicin de bsqueda es NULL, el grupo de filas se descarta y no contribuye con
una fila resumen a los resultados de la consulta.
- Si la clusula HAVING aparece sin GROUP BY, SQL considera el conjunto entero de
resultados detallados como un nico grupo. El uso de la clusula HAVING si la
correspondiente clusula GROUP BY casi nunca se ve en la prctica.
select sum(horas)
from trabaja_en, proyecto
where nump=numerop
having sum(horas)>30
order by sum (horas)desc;
Resultado:
SUM (HORAS)
275
Mnimo 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 mnimo 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 reorganizacin.

select round(avg(nvl(horas,0)),2)
from proyecto p, trabaja_en t
where nump=p.numerop
and upper(nombrep)=REORGANIZACIN;

Otra forma:
select nump,nombrep,avg(nvl(horas,0))
from trabaja_en, proyecto
where nump=numerop
and nombrep=Reorganizacin
group by nombrep;


IMPORTANTISIMO EL NVL!!!!
Fecha de nacimiento del empleado mayor

select min(fechanac)
from empleado;

Resultado:
min(fechanac) : 10/11/27 (el ms viejo)

Para que salgan los nombres de los nacidos a partir de 1950:
select nombrep
from empleado
where to_char(fechanac, yyyy)>1950;


El ms 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

Relacin de proyectos(nombre, nmero de proyecto) y nmero 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;



Nmero y nombre de proyectos en los que se trabaje ms de 45 horas.

select nombrepNombre proyecto, numeropNumero 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 ms 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 seleccin
from especificacin de tabla
where condicin de bsqueda
group by columna de agrupacin
having condicin de bsqueda)






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 seleccin, en la clusula WHERE o en la clusula HAVING de la
ocnsulta principal.
Una subconsulta va siempre entre parntesis.
Una subconsulta debe producir una nica columna de datos como resultado. Esto significa que
una subconsulta siempre tiene un nico elemento de seleccin en su clusula SELECT.
La clusula ORDER BY no puede ser especificada en una subconsulta.
Una subconsulta no puede ser la UNIN 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 clusula WHERE
Las subconsultas suelen ser utilizadas principalmente en la clusula WHERE de una sentencia
SQL.
Cuando aparece una subconsulta en la clusula WHERE sta funciona como parte del proceso
de seleccin de filas.
ejemplo: empleado que ms gana:

Sacar el empleado que ms 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 comparacin subconsulta:
(=,<>,!=,^=,<,<=,>,>=)
Ejemplo:
Nombre y salario del empleado que es gerente del departamento Investigacin.
select nombrep,salario
from empleado
where nss=(select nss
from departamento
where nombred=Investigacion);

Personal perteneciente (nombre) al departamento de Investigacin.
select nombrep
from empleado
where nd=(select numerod
from departamento
where upper(nombred)=INVESTIGACIN);

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 algn dependiente:
select nombrep,nss
from empleado
where nss in(select distinct(nss)
from dependiente);
Saca los empleados que no tengan ningn dependiente:
select nombrep,nss
from empleado
where nss not in(select distinct(nss)
from dependiente);
Relacin de empleados que no dirigen ningn 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:
Relacin de los empleados del departamento de investigacin:
select nombrep, salario
from empleado
where exists(select*
from departamento
where nd=numerod
and nombred=Investigacin);


Otra forma de hacerlo:
select nombrep,salario
from empleado,departamento
where nd=numerod
and upper(nombred)=INVESTIGACIN;

Otra forma:
select nombrep,salario
from empleado
where nd=(select numerod
from departamento
where nombred=Investigacin);

Relacin entre la resta minus, not in y not exists
Supongamos de la base de datos ejemplo
La siguiente cuestin:
Obtener los cdigos de los proyectos suministrados nicamente por S1 (ejemplo Sevilla).
select spj1.j
from spj spj1 (lo renombro para que no haya ambigedades)
where spj1.s= S1
minus
select spj2.j
from spj spj2 (lo renombro para que no haya ambigedades)
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 ms:
select distinct spj1.j
from spj spj1
where spj.j not in (select spj2.j
from spj spj2
where spj.s != S1;


Obtener los cdigos de los proyectos no suministrados por S1.
select distinct spj2.j
from spj spj2
where spj2.s!='S1';


Divisin: r/s (palabra clave TODAS)
Relacin 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: Relacin de empleados que trabajan en todos los proyectos:
Primero haremos la divisin 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 algn valor en una columna de los resultados de la
subconsulta. SQL proporciona dos test cuantificados, ANY y ALL, que extienden esta nocin a
otros operadores de comparacin 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 comparacin 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)<ANY (select ventas
from RPVENTAS
where oficina_rep=oficina);


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 hallaramos el valor mayor para luego comparar)
select max(sum(ventas))
from repventas
group by oficina_rep;


El any y el some son equivalentes.

Si buscramos 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 tambin con uno de los seis operadores de comparacin 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 comparacin 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 investigacin.
select nombrep, salario, nd
from empleado
where nd=(select numerod
from departamento
where nombred=Investigacin);

Si me piden tambin el nombre de departamento:
select nombrep,salario,(select nombred from departamento where
nombred='Investigacin')departamento
from empleado
where nd=(select numerod
from departamento
where nombred='Investigacin');


Sin subselect:
select nombrep,salario,nd
from empleado, departamento
where nd=numerod
and nombred=Investigacin;

Si me piden tambin el nombre de departamento:
select nombrep,salario,nombred
from empleado, departamento
where nd=numerod
and nombred='Investigacin';

Subconsultas usadas en cualquier lugar de una expresin:
Una subconsulta se puede usar all donde se pueda usar una expresin 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 WHERE
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 Automatizacin:
select nombrep
from empleado
where nss in(select nss
from trabaja_en
where nump in(select numerop
from proyecto
where nombrep=Automatizacin);



Subconsultas correlacionadas:
Una subconsulta correlacionada es una subconsulta que contiene una referencia a una
tabla que tambin aparece en la consulta exterior.
En una subconsulta correlacionada, las consultas principales y subordinadas extraen datos
de la misma tabla.


Subconsultas en la clusula HAVING:
Aunque las subconsultas suelen encontrarse sobre todo en la clusula WHERE, tambin
pueden utilizarse en la clusula HAVING. Cuando aparece en este clusula, funciona como
parte de la seleccin de grupo de las filas efectuadas por la clusula HAVING.

Ejemplo: Seleccionar el nombre, salario, nss y horas del trabajador que ms 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, sum(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 clusula 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 clusula having, los resultados de la
subconsulta se utilizar para seleccionar los grupos
4.
5. La forma subconsulta del test de comparacin utiliza uno de los operadores de
comparacin 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 algn valor.
8. Los test cuantificados (any y all) utilizan uno de los operadores de comparacin
simple para comparar un valor de test con todos los valores devueltos con una
subconsulta, comprobando si la comparacin 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);