SQL - Consulta SQL; Listar TODOS los alumnos que cursen determinado curso.

Hola, hace ya un día que estoy peliando con la misma f0cking consulta de SQL, es sencillo pero a la vez muy molesto porque todas las soluciones que me han propuesto mis profesores y mis compañeros tiran resultados erroneos. Realmente simple, es lo siguiente:

Listar nombre y apellido de los alumnos que hayan cursado todos los cursos.

Acá tienen la tabla para hacerse una idea.

PERSONA = (DNI, Apellido, Nombre, Fecha_Nacimiento, Estado_Civil, Genero)
ALUMNO = (DNI, Legajo, Año_Ingreso)
PROFESOR = (DNI, Matricula, Nro_Expediente)
TITULO = (Cod_Titulo, Nombre, Descripción)
TITULO-PROFESOR = (Cod_Titulo, DNI, Fecha)
CURSO = (Cod_Curso, Nombre, Descripción, Fecha_Creacion, Duracion)
ALUMNO-CURSO = (DNI, Cod_Curso, Año, Desempeño, Calificación)
PROFESOR-CURSO = (DNI, Cod_Curso, Fecha_Desde, Fecha_Hasta)

Yo ya trate con los siguientes razonamientos

1) Usar conjuntos; saco el conjunto de los alumnos que no cursaron ninguna materia y se lo resto al conjunto de alumnos en general, con un pequeño problema; el complemento de NINGUNO no es TODOS, sino ALGUNOS

2) Usar NOT EXISTS; Lo encare asi "Los alumnos que no hayan no cursado ninguna materia", el resultado es el mismo que con conjuntos, me devuelve los alumnos que hayan cursado al menos 1 materia

3) Usar COUNT; este si funciona, pero es recontra ineficiente, ya que ha recibido tantas criticas estoy un poco desesperado por encontrar una consulta que haga lo que el enunciado pide y no use COUNT

Si ha alguno de ustedes se les ocurre alguna idea, se los agradecería un montón, además cualquier código que se les venga a la mente, si quieren lo publican y yo lo tiro en la base de datos y les digo que tal salio.

Muchas gracias por detenerse a leer.

Aproposito, acá les dejo el link del tema donde publique el código del COUNT:
http://foro.elhacker.net/desarrollo_web/consulta_sqllistar_elementos_que_estan_presentes_en_todos_los_elementos_de_otra-t343529.0.html

Hola Agustin Tomas Larghi:

No entiendo por qué dices que utilizar COUNT es "recontra ineficiente"... en lo particular creo que justamente esta es la manera más eficiente de hacer la consulta que planteas, lo único que debes tener cuidado sería en tener un buen manejo de índices...

Ahora bien, si insistes no utilizar la función COUNT se me ocurre otra solución, y es crear un producto cartesiano entre tus tablas ALUMNOS y CURSOS para obtener todas las combinaciones que deberían existir en tu tabla ALUMNOS_CURSOS, de tal suerte que si no existe, entonces quiere decir que ese alumno NO HA TOMADO CIERTO CURSO... suena medio complicado, pero veamos si con el script queda un poco más claro mi idea:



Observa con estos datos que pongo de ejemplo, el alumno 1 no ha tomado el curso de 4, el alumno 2 ha tomado los cuatro cursos, el alumno 3 ha tomado 4 cursos, pero el curso 1 lo ha tomado dos veces, por lo tanto también le falta tomar el curso 4. El alumno 4 no ha tomado ningún curso. Tú podrías hacer lo siguiente:



Observa que en la consulta interna hago un producto cartesiano entres alumnos cursos obtengo aquellas parejas que no existen en alumnos_cursos, si ejecutas sólo la consulta interna te dará justamente la lista de los curso que los alumnos les falta tomar:



Por lo tanto, utilizar esta consulta para filtrar los alumnos. Dale un vistazo para ver si es más eficiente o no que la opción del COUNT y nos comentas los resultados.

Saludos
Leo.

Olvidé pedirte que nos digas con que motor de BD estás trabajando, ya que algunos proporcionan funciones especiales para el manejo de conjunto (EXCEPT, MINUS, INTERSECT, ETC). La solución que pongo sería utilizando sólo SQL Estándar y por tanto debería funcionar para todos los motores, pero sería conveniente que nos digas con qué estás trabajando, es posible que existan algunas otras maneras más óptimas para llegar al mismo resultado.

Saludos
Leo.

Hola y muchas gracias por responder.

Justamente estoy trabajando con el SQL estandar.

Por suerte tu solucion me sirvio bastante estaba tratando de hacer una solucion alternativa usando NOT EXISTS, pero no la podia sacar, por suerte tu manera es justo la que necesitaba destrabar.

Acerca de porque digo que es recontra ineficiente usar COUNT es por lo siguiente;
Me lo señalo mi profesor, afirmando que la manera correcta era usando NOT EXISTS encarandolo de manera que detalle en el inciso 2.

Muchas gracias Leo, saludos.

No estoy totalmente de acuerdo con la afirmación de tu profesor, acerca de que la manera "correcta" de hacerlo es usando NOT EXISTS, por experiencia propia te puedo decir que manejar funciones de agrupación en tablas enormes (y al decir enormes me refiero a varios millones de registros) suele ser mucho más rápido que manejar todos los registros, de hecho una de las mejores prácticas al escribir consultas es la de evitar usar sentencias NOT IN y NOT EXISTS en la medida de lo posible, ya que estas consultas implican tener que revisar todos los registros cada vez, lo que puede afectar el rendimiento. Es por eso que hacía énfasis en el buen manejo de los índices, independientemente que lo hagas con COUNT o con NOT EXISTS. Finalmente, sería un buen ejercicio que probaras las dos consultas, he inclusive que preguntaras a tu profesor si él tiene una lógica diferente para llegar al mismo resultado y probar todas las consultas en el servidor, con un número considerable de registros, para ver cómo se comportan y puedas entonces decidirte por una de ellas.

Afortunadamente la mayoría de los problemas en BD tienen más de una solución, tal como diría otro compañero forista "hay muchas formas de matar una mosca, pero usar una pistola puede resultar excesivo". Haz la prueba y nos comentas los resultados.

Saludos
Leo.

Muy agradecido, busqué muchísimo por días... Gracias por compartir sus conocimientos

Tengo una idea de como resolver tu problema.
Te aclaro que es un teorización basada en conjuntos, por lo que deberías comprender la idea para poder depurar el código. Yo sólo te paso la idea.
Si la aplicás, creo que sería conveniente que las utilizaras mediante vistas (View).
Analizá la idea, pero si encontrás alguna cláusula que te resuelva de manera simple el problema y en un solo comando, bienvenida sea! Suerte!

Esta consulta te devolvería la totalidad de combinaciones [DNI, Cód_Curso] que podrían formarse entre Alumnos y Cursos, sin importar que los Alumnos hayan hecho o no los Cursos. Sería tu 'Universo'.
* Se usa SIN la cláusula WHERE, quizás no sea compatible en todos los motores.
Devolvería una cantidad de registros igual a la multiplicación de las cantidades de cada archivo.
El valor 1000, es una unidad seguida de tantos ceros como la cant máxima de dígitos vaya a tener el campo Cod_Curso. Es una emulación de concatenación de ambos campos pero en formato numérico.
SELECT
Alumnos.dni*1000+Cursos.Cod_Curso AS CombAluCur
Alumnos.dni,
Cursos.Cod_Curso
FROM
Alumnos,
Cursos
INTO CURSOR Universo

Esta consulta te devolvería el conjunto de combinaciones [DNI , Cod_Curso] que se forman a partir de los cursos registrados en la tabla AlumnosCursos, es decir, los cursos efectivamente realizados, y obviamente los alumnos que los cursaron.
SELECT
Alumnos.dni*1000+Cursos.Cod_Curso AS CombAluCur,
Alumnos.dni,
Cursos.Cod_Curso
FROM
Alumnos,
Cursos,
AlumnosCursos
WHERE Alumnos.dni=AlumnosCursos.dni AND
Cursos.Cod_Curso=AlumnosCursos.Cod_Curso
INTO CURSOR CursosRealizados


Esta consulta te devolvería las combinaciones de tu 'universo' que aún NO se utilizaron, es decir, todos los alumnos que no hayan cursado alguno o todos los cursos y a la vez todos los cursos que no hayan sido relacionados aún con los registros de alumnos.

SELECT
CombAluCur
FROM
Universo
WHERE Universo.CombAluCur NOT IN (SELECT CombAluCur FROM CursosRealizados)
INTO CURSOR CombNoUtilizadas


Si analizás como conjuntos las consultas anteriores, verás que la unión de las dos últimas es igual al conjunto universal -> Universo = CursosRealizados U CombNoUtilizadas

Ahora bien, lo que a vos te interesa encontrar son los Alumnos que están relacionados con el conjunto CursosRealizados pero que NO están relacionados con el conjunto CombNoUtilizadas, que es el caso de los alumnos que realizan todos los cursos, ya que sus códigos al combinarse con todos los códigos de cursos existentes (por cursarlos a todos), quedan relacionados sólamente con el conjunto CursosRealizados.
Esto sería compatible con la siguiente consulta:
*** Importante la cláusula DISTINCT para no repetir registros del mismo alumno
*** Pedir sólo el dni y usarlo como origen en consultas posteriores.
SELECT DISTINCT
dni
FROM
CursosRealizados
WHERE CursosRealizados.CombAluCur NOT IN (SELECT CombAluCur FROM Universo)
INTO CURSOR AluTodosCur


Y si todo funciona bien, esta consulta final te devolvería el listado que necesitás:
SELECT
Alumnos.Apellido,
Alumnos.Nombre
FROM
Alumnos,
AluTodosCur
WHERE
Alumnos.dni=AluTodosCur.dni

¿¿¿ Andará ??? Suerte!

Luego de enviar mi respuesta, vi la respuesta de Leonardo. Básicamente es la misma idea, mi conjunto Universo es el Producto Cartesiano que él mencionó.
Analizando las 2 respuestas podrás entender aún mejor la solución.
Fijate en la forma que Leonardo definió el producto cartesiano, ya que quizás en tu motor sea obligatorio el uso de la cláusula WHERE, que yo no la utilizo en la primer consulta. Yo uso mucho SQL pero en Visual FoxPro, por ello deberías adecuar la sintaxis al ejemplo de Leonardo, por ser de MySQL.