Práctica en línea de consultas SQL básicas: 20 ejercicios para principiantes

Estos 20 ejercicios son justo lo que necesitan los principiantes para practicar consultas SQL. Intenta resolver cada uno de ellos y luego mira las soluciones. Si hay que aclarar algo, hay explicaciones para cada solución.

En este artículo, se hablará menos de lo habitual. En su lugar, vas a escribir las respuestas a las consultas SQL de práctica. (No te preocupes; hemos incluido las soluciones por si te quedas atascado.) El objetivo es darte, como principiante, muchas oportunidades para practicar consultas SQL.

He seleccionado veinte ejemplos de nuestro Basic Ejercicio de SQL: Run Track Through Queries!. Si al final del artículo crees que necesitas practicar más -¡te lo recomiendo de todo corazón! - encontrarás casi 100 ejercicios SQL interactivos más en ese curso. Cubren temas como la consulta de una tabla, el uso de JOINs, la ordenación de datos con ORDER BY, la agregación de datos y el uso de GROUP BY, el manejo de NULLs, la realización de operaciones matemáticas y la escritura de subconsultas.

Todos estos son temas que cualquier principiante en SQL debería conocer bien antes de pasar a temas más complejos. La mejor manera de aprender cualquier cosa en SQL es escribir constantemente tu propio código. De esta forma, dominarás la sintaxis SQL y sus características básicas; además, entenderás la resolución de problemas. Después de todo, el objetivo de conocer SQL es saber cómo utilizar los datos para resolver problemas.

Y puedes ir aún más lejos. Tenemos el Ejercicio de SQL y el curso mensual Ejercicio de SQL para practicar aún más las consultas SQL.

Dicho esto, pasemos directamente a la práctica de SQL, empezando por el conjunto de datos.

• Conjunto de Datos
• Ejercicio #1: Mostrar las Fechas Finales de Todos los Eventos y los Puntos de Viento
• Ejercicio nº 2: Mostrar todas las finales en las que el viento fue superior a 0,5 puntos
• Ejercicio #3: Mostrar Todos los Datos de Todos los Maratones
• Ejercicio nº 4: Mostrar todos los resultados finales de los corredores no participantes
• Ejercicio nº 5: Mostrar todos los datos de los resultados de los corredores que no tomaron la salida
• Ejercicio nº 6: Mostrar los nombres de las carreras masculinas de menos de 500 metros
• Ejercicio nº 7: Ordenar nombres de países y abreviaturas
• Ejercicio nº 8: Ordenar los nombres y apellidos de los atletas
• Ejercicio nº 9: Ordenar resultados finales de más de tres horas
• Ejercicio nº 10: Mostrar los nombres y lugares de los 3 primeros atletas
• Ejercicio nº 11: Mostrar todos los maratones con el nombre de la competición, el año de la competición y el nombre de la disciplina
• Ejercicio nº 12: Mostrar las puntuaciones de Mo Farah en todas las disciplinas
• Ejercicio #13: Mostrar los Nombres de las Competiciones y el Número de Pruebas
• Ejercicio nº 14: Mostrar los nombres de los atletas más populares
• Ejercicio nº 15: Mostrar cada país y el número de atletas que terminaron sin plaza
• Ejercicio nº 16: Calcular el ritmo medio de cada carrera
• Ejemplo nº 17: Encontrar todos los tiempos más rápidos que la media para carreras de 1.500 metros
• Ejercicio nº 18: Encontrar todos los atletas que corrieron al menos en dos pruebas de una competición
• Ejercicio nº 19: Mostrar corredores que sólo llegaron primeros
• Ejercicio nº 20: Encontrar Todos Los Atletas Que No Empezaron Y Que Ganaron Al Menos Una Vez

Práctica de Consulta SQL

Conjunto de Datos

El conjunto de datos contiene datos sobre las finales de las competiciones de atletismo en pista de los campeonatos de atletismo: Juegos Olímpicos de Río de Janeiro en 2016, Campeonato Mundial de Atletismo de la IAAF de Londres en 2017 y Campeonato Mundial de Atletismo de la IAAF de Doha en 2019.

Los datos se almacenan en seis tablas: competition, event, discipline, final_result, athletey nationality. El esquema se muestra a continuación:

La información de la competición se almacena en la tabla competition. Tiene las siguientes columnas:

• id - El ID de la competición y la clave primaria de la tabla.
• name - El nombre de la competición.
• start_date - Primer día de la competición.
• end_date - El último día de la competición.
• year - Año de la competición.
• location - El lugar de la competición.

Estos son los datos de la tabla.

id	name	start_date	end_date	year	location
7093747	Rio de Janeiro Olympic Games	2016-08-12	2016-08-21	2016	Estádio Olímpico, Rio de Janeiro (BRA)
7093740	London IAAF World Championships in Athletics	2017-08-04	2017-08-13	2017	Olympic Stadium, London (GBR)
7125365	IAAF World Championships in Athletics	2019-09-27	2019-10-06	2019	Khalifa International Stadium, Doha (QAT)

La tabla discipline contiene información para todas las disciplinas de atletismo. Tiene estas columnas

• id - El ID de la disciplina y la clave primaria de la tabla.
• name - El nombre de la disciplina.
• is_men - TRUE si es una disciplina masculina, FALSE si es femenina.
• distance - La distancia de la disciplina, en metros.

Esta es una instantánea de las cinco primeras filas de datos:

id	name	is_men	distance
1	Men's 100m	TRUE	100
2	Men's 200m	TRUE	200
3	Men's 400m	TRUE	400
4	Men's 800m	TRUE	800
5	Men's 1500m	TRUE	1,500

La siguiente tabla es Evento, que almacena información sobre cada evento en particular:

• id - El ID del evento y la clave primaria de la tabla.
• competition_id - Vincula la prueba a una competición.
• discipline_id - Vincula el evento a una disciplina.
• final_date - Cuándo se celebró la final de este evento.
• wind - Los puntos de viento durante la final.

Estas son las cinco primeras filas de esta tabla:

id	competition_id	discipline_id	final_date	wind
1	7093747	1	2016-08-14	0.2
2	7093747	2	2016-08-18	-0.5
3	7093747	3	2016-08-14	0
4	7093747	4	2016-08-15	0
5	7093747	5	2016-08-20	0

Los datos sobre cada atleta están en la tabla atleta:

• id - El ID del atleta y la clave principal de la tabla.
• first_name - El nombre del atleta.
• last_name - Apellido del atleta.
• nationality_id - Nacionalidad del atleta.
• birth_date - Fecha de nacimiento del atleta.

Estas son las cinco primeras filas:

id	first_name	last_name	nationality_id	birth_date
14201847	Usain	BOLT	1	1986-08-21
14238562	Justin	GATLIN	2	1982-02-10
14535607	André	DE GRASSE	3	1994-11-10
14201842	Yohan	BLAKE	1	1989-12-26

La tabla nationality contiene información sobre el país:

• id - El ID del país y la clave principal de la tabla.
• country_name - El nombre del país.
• country_abbr - La abreviatura de tres letras del país.

A continuación se muestra una instantánea de cinco filas de esta tabla:

id	country_name	country_abbr
1	Jamaica	JAM
2	United States	USA
3	Canada	CAN
4	South Africa	RSA
5	Côte d’Ivoire	CIV

La última tabla es final_result. Contiene información sobre los participantes y sus resultados en un evento concreto:

• event_id - ID de la prueba.
• athlete_id - El atleta
• result - El tiempo/puntuación del atleta (puede ser NULL).
• place - El puesto obtenido por el atleta (puede ser NULL).
• is_dsq - TRUE si ha habidodescalificación.
• is_dnf - TRUE si el atleta no terminóla carrera.
• is_dns - TRUE si el atleta no comenzóla carrera.

Esta es la instantánea:

event_id	athlete_id	result	place	is_dsq	is_dns	is_dnf
1	14201847	0:00:10	1	FALSE	FALSE	FALSE
1	14238562	0:00:10	2	FALSE	FALSE	FALSE
1	14535607	0:00:10	3	FALSE	FALSE	FALSE
1	14201842	0:00:10	4	FALSE	FALSE	FALSE
1	14417763	0:00:10	5	FALSE	FALSE	FALSE

Ahora que ya has echado un buen vistazo al conjunto de datos, ¡empecemos nuestra práctica de consulta SQL básica! Todos los ejercicios requerirán que conozcas algo de SQL, así que asegúrate de que conoces todos los elementos básicos de una consulta SQL.

Ejercicio #1: Mostrar las Fechas Finales de Todos los Eventos y los Puntos de Viento

Ejercicio: Encontrar las fechas finales de todos los eventos y los puntos de viento.

Solución:

SELECT
  final_date,
  wind
FROM event;

Explicación: Los datos que necesitas están en la tabla evento. Tienes que seleccionar dos columnas de ella: final_date y wind. Para ello, escribe la primera columna en la sentencia SELECT. A continuación, escribe el nombre de la segunda columna y separa los nombres de las columnas con una coma.

Por último, haz referencia a la tabla en la cláusula FROM.

Salida:

final_date	wind
2016-08-14	0.2
2016-08-18	-0.5
2016-08-14	0
2016-08-15	0
2016-08-20	0

Ejercicio #2: Mostrar todas las finales donde el viento fue superior a 0.5 puntos

Ejercicio: Mostrar todas las fechas de finales con un viento superior a 0.5 puntos.

Solución:

SELECT final_date
FROM event
WHERE wind > 0.5;

Explicación: Primero, seleccione la columna final_date de la tabla event. Con eso, obtendrías una lista de todas las finales. Sin embargo, no necesitas toda la lista, sino sólo las finales en las que el viento era superior a 0,5.

Por lo tanto, necesitas filtrar los datos utilizando la cláusula WHERE. En ella, escribes el nombre de la columna que quieres filtrar; en este caso, es la columna wind. Para obtener el viento superior a 0.5, utiliza el operador lógico 'mayor que' (>).

Salida:

final_date
2017-08-11
2019-09-28
2019-10-02

Ejercicio #3: Mostrar todos los datos de todas las maratones

Ejercicio: Mostrar los datos de disciplina para todos los maratones.

Solución:

SELECT *
FROM discipline	
WHERE name LIKE '%Marathon%';

Explicación: Para seleccionar todas las columnas, no tienes que escribir sus nombres explícitamente. Existe una abreviatura para "todas las columnas" llamada asterisco (*). En lugar de los nombres de las columnas, pon un asterisco en SELECT.

Luego, cuando quieras datos de la tabla disciplinese hace referencia a ella en FROM.

Por último, tienes que filtrar los datos. Utilice WHERE y el operador LIKE. Este operador busca entre los datos textuales de la columna y devuelve todas las filas que contengan el texto de la condición WHERE. En otras palabras, la condición buscará la palabra "Maratón". Debe poner la palabra entre comillas simples.

Sin embargo, no conoce el nombre exacto de la disciplina; sólo sabe que debe contener esa palabra. Puede estar en cualquier parte del nombre de la disciplina: al principio, en medio o al final. Para buscar en cualquier lugar de la cadena, ponga el operador módulo (%) antes y después de la palabra que está buscando.

Salida:

id	name	is_men	distance
8	Men's Marathon	TRUE	42,195
16	Women's Marathon	FALSE	42,195

Ejercicio nº 4: Mostrar todos los resultados finales de los corredores no clasificados

Ejercicio: Mostrar todos los datos de los resultados finales de los corredores que no clasificaron.

Solución:

SELECT *
FROM final_result
WHERE place IS NULL;

Explicación: Necesita todas las columnas, así que use un asterisco en SELECT y haga referencia a la tabla final_result en FROM.

Necesita mostrar sólo aquellos resultados donde los corredores terminaron sin un lugar. Esta vez también utilizarás WHERE y filtrarás por la columna place. Si un corredor termina sin plaza, la columna place estará vacía (es decir, será NULL). Necesita el operador IS NULL después del nombre de la columna para devolver todas estas filas.

Sería conveniente saber qué es un NULL en SQL antes de utilizar el operador IS NULL.

Salida:

event_id	athlete_id	result	place	is_dsq	is_dns	is_dnf
6	14464221	NULL	NULL	TRUE	FALSE	FALSE
7	14530623	NULL	NULL	FALSE	FALSE	TRUE
7	14573513	NULL	NULL	FALSE	FALSE	TRUE
8	14167397	NULL	NULL	FALSE	FALSE	TRUE
8	14177784	NULL	NULL	FALSE	FALSE	TRUE

Ejercicio #5: Mostrar todos los datos de los resultados de los corredores que no empiezan

Ejercicio: Mostrar todos los datos de resultados de los corredores que no iniciaron la carrera.

Solución:

SELECT *
FROM final_result
WHERE is_dns IS TRUE;

Explicación: Seleccione todas las columnas de la tabla final_result usando un asterisco y referenciando la tabla en FROM.

A continuación, utilice WHERE y filtre la columna por is_dns. Si el corredor no comenzó la carrera, esta columna tendrá el valor TRUE. Por lo tanto, necesita utilizar el operador IS TRUE después del nombre de la columna.

Resultado: Esta es la salida completa:

event_id	athlete_id	result	place	is_dsq	is_dns	is_dnf
14	14451797	NULL	NULL	FALSE	TRUE	FALSE
16	14296979	NULL	NULL	FALSE	TRUE	FALSE
19	14176330	NULL	NULL	FALSE	TRUE	FALSE
22	14367867	NULL	NULL	FALSE	TRUE	FALSE
24	14219653	NULL	NULL	FALSE	TRUE	FALSE
24	14225279	NULL	NULL	FALSE	TRUE	FALSE
32	14751813	NULL	NULL	FALSE	TRUE	FALSE
41	14291986	NULL	NULL	FALSE	TRUE	FALSE

Ejercicio #6: Mostrar los Nombres de las Carreras Masculinas por Disciplina de Menos de 500 Metros

Ejercicio: Mostrar solo los nombres de las disciplinas masculinas donde la distancia a correr es menor a 500 metros.

Solución:

SELECT name
FROM discipline
WHERE is_men IS TRUE
  AND distance < 500;

Explicación: Primero, seleccione el nombre de la columna de la tabla discipline.

De nuevo necesita filtrar los datos - esta vez, poniendo dos condiciones en WHERE.

La primera condición es que sea una disciplina masculina. Por lo tanto, tienes que filtrar la columna is_men utilizando el operador IS TRUE. A continuación, añades la segunda condición: los valores de la columna distance tienen que ser inferiores a 500. Esta condición utiliza el operador menor que (<). Como ambas condiciones tienen que cumplirse, separa las condiciones utilizando el operador AND.

Salida:

name
Men's 100m
Men's 200m
Men's 400m

Ejercicio #7: Ordenar Nombres de Países y Abreviaturas

Ejercicio: Mostrar todos los nombres y abreviaturas de los países. Ordene la salida alfabéticamente por nombre de país.

Solución:

SELECT
  country_name,
  country_abbr
FROM nationality
ORDER BY country_name ASC;

Explicación: Selecciona el nombre del país y su abreviatura en la tabla nationality.

Para ordenar la salida, utilice la cláusula ORDER BY. Si desea ordenar por nombre de país, escriba country_name en ORDER BY. La salida debe ordenarse alfabéticamente, así que utiliza la palabra clave ASC (ascendente) después del nombre de la columna.

Resultado: Aquí están las primeras cinco filas de la salida:

country_name	country_abbr
Afghanistan	AFG
Algeria	ALG
American Samoa	ASA
Andorra	AND
Angola	ANG

Ejercicio #8: Ordenar los Nombres y Apellidos de los Atletas

Ejercicio: Mostrar el nombre y apellido de cada atleta. Ordene el resultado descendentemente por el nombre del atleta. Si varios atletas tienen el mismo nombre, muestre sus apellidos ordenados descendentemente.

Solución:

SELECT
  first_name,
  last_name
FROM athlete
ORDER BY first_name DESC, last_name DESC;

Explicación: Seleccionar el nombre y apellidos de la tabla athlete.

A continuación, añada la cláusula ORDER BY. La primera ordena por el nombre de pila de forma descendente, añadiendo DESC después del nombre de la columna. La segunda condición de ordenación ordena por el apellido, también de forma descendente. De nuevo, escriba el nombre de la columna y añada DESC. Las condiciones deben ir separadas por una coma.

Resultado: Aquí están las primeras cinco filas de la salida:

first_name	last_name
Zsófia	ERDÉLYI
Zouhair	AWAD
Zoey	CLARK
Zoe	HOBBS
Zoe	BUCKMAN

Ejercicio #9: Ordenar Resultados Finales en Tres Horas

Ejercicio: Para todos los resultados finales, muestre los tiempos que son de al menos tres horas. Ordene las filas por el resultado en orden descendente.

Solución:

SELECT result
FROM final_result
WHERE result >= INTERVAL '3 hours'
ORDER BY result DESC;

Explicación: Seleccione la columna result de la tabla final_result.

A continuación, utilice WHERE para encontrar los resultados que están por debajo de tres horas. Puede utilizar los operadores "mayor que o igual" (>=) y INTERVAL.

Los datos de la columna de resultados tienen formato de hora. Por lo tanto, necesita utilizar INTERVAL para obtener la parte específica (intervalo) de esos datos. En este caso, son tres horas. Simplemente escriba '3 horas' después de INTERVAL.

Por último, ordene la salida de forma descendente por el resultado.

Salida: Aquí están las primeras cinco filas de la salida:

result
3:20:20
3:16:11
3:15:18
3:11:31
3:11:05

Ejercicio #10: Mostrar los nombres y lugares de los 3 mejores atletas

Ejercicio: Para cada atleta que alguna vez subió al podio (es decir, terminó entre los 3 primeros), muestre su apellido y nombre y su lugar.

Solución:

SELECT
  a.last_name,
  a.first_name,
  fin.place
FROM athlete a
JOIN final_result fin
  ON a.id = fin.athlete_id
WHERE fin.place <= 3;

Explicación: En este ejercicio, necesitas utilizar datos de dos tablas: athlete y final_result. Empecemos la explicación desde la cláusula FROM.

Haces referencia a la tabla athlete y le das un alias 'a', para no tener que escribir el nombre completo de la tabla en otra parte de la consulta. Para obtener también datos de otra tabla, es necesario unir las tablas. En este caso, utilice JOIN, que devolverá sólo las filas coincidentes de ambas tablas. Para ello, basta con hacer referencia a la tabla final_result en JOIN y añadiendo el alias 'fin'.

A continuación, debe especificar la condición de unión mediante la palabra clave ON. Las tablas se unen en columnas compartidas: id de athlete y athlete_id de final_result. Busca filas en las que los valores de estas dos columnas sean iguales, por lo que debe colocar un signo igual (=) entre ellas. Delante del nombre de cada columna, pon el alias de la tabla seguido de un punto para que la base de datos sepa en qué tabla está esa columna.

Ahora que ha unido las tablas, puede seleccionar las columnas. Delante del nombre de cada columna, pon el alias de la tabla por la misma razón que hemos explicado antes. Ahora, ya tienes los apellidos y nombres de los deportistas y sus lugares.

Como último paso, simplemente filtra los datos utilizando WHERE y la columna place. Estás buscando podios, por lo que los valores deben ser iguales o inferiores a tres. Utilice el operador "menor o igual" (<=).

Esta práctica de consulta SQL requiere que conozcas Tipos de JOIN en SQL. Si todavía no estás seguro de cómo funcionan, mira estas preguntas de práctica deTipos de JOIN en SQL antes de pasar a otros ejercicios.

Resultado: Aquí están las primeras cinco filas de la salida:

last_name	first_name	place
BOLT	Usain	3
BOLT	Usain	1
BOLT	Usain	1
GATLIN	Justin	2
GATLIN	Justin	1

Ejercicio #11: Mostrar Todos los Maratones con su Nombre de Competencia, Año de Competencia y Nombre de Disciplina

Ejercicio: Mostrar todos los maratones, el nombre (renombre esta columna competition_name) y año de la competencia, y el nombre de la disciplina (renombre esta columna discipline_name).

Solución:

SELECT
  c.name AS competition_name,
  c.year,
  d.name AS discipline_name
FROM competition c
JOIN event e
  ON e.competition_id = c.id
JOIN discipline d
  ON e.discipline_id = d.id
WHERE d.name LIKE '%Marathon%';

Explicación: Este ejercicio muestra cómo unir varias tablas. El principio es el mismo que con dos tablas. Sólo tiene que añadir más JOINs y las condiciones de unión.

En este caso, se unen las tablas competition y event donde e.competition_id es igual a c.id column.

A continuación, hay que añadir la tabla discipline a la cadena de unión. Escriba de nuevo JOIN y haga referencia a la tabla discipline. Añada la condición de unión: la columna discipline_id de la tabla event debe ser igual a la columna id de la tabla discipline tabla.

Ahora, selecciona las columnas necesarias, acordándote de poner el alias de la tabla delante de cada columna. Alias competition_name y discipline_name utilizando la palabra clave AS para darles los nombres de columna descritos en las instrucciones.

Por último, filtra los resultados para mostrar sólo las disciplinas del maratón.

Resultado:

competition_name	year	discipline_name
Rio de Janeiro Olympic Games	2016	Men's Marathon
Rio de Janeiro Olympic Games	2016	Women's Marathon
London IAAF World Championships in Athletics	2017	Men's Marathon
London IAAF World Championships in Athletics	2017	Women's Marathon
IAAF World Championships in Athletics	2019	Men's Marathon

Ejercicio #12: Mostrar las puntuaciones de Mo Farah para todas las disciplinas

Ejercicio: Mostrar las puntuaciones de Mo Farah (atleta ID de 14189197) para todas las disciplinas. Mostrar NULL si nunca ha participado en una disciplina dada. Mostrar los nombres, fechas, lugares y resultados de todas las disciplinas masculinas.

Solución:

SELECT
  d.name AS discipline_name,
  e.final_date,
  fin.place,
  fin.result
FROM discipline d
LEFT JOIN event e
  ON e.discipline_id = d.id
LEFT JOIN final_result fin
  ON fin.event_id = e.id
 AND athlete_id = 14189197
WHERE is_men IS TRUE;

Explicación: Unir las tablas discipline y event en las columnas discipline_id y id. Debe utilizar LEFT JOIN. Este tipo de unión devolverá todas las filas de la primera tabla (izquierda) y sólo las filas coincidentes de la segunda tabla (derecha). Si no hay filas coincidentes, los valores serán NULL. Esto es ideal para este ejercicio, ya que necesitas mostrar todas las disciplinas y utilizar NULLs si Mo Farah nunca ha participado en la disciplina.

La siguiente unión también es LEFT JOIN. Une la tabla event con la tabla final_result. La primera condición de unión aquí une las tablas en las columnas event_id y id. También necesita incluir la segunda condición añadiendo la palabra clave AND. Esta segunda condición sólo buscará los datos de Mo Farah, es decir, el atleta con el ID 14189197.

Como último paso, utilice WHERE para encontrar sólo las disciplinas masculinas.

Resultado:

discipline_name	final_date	place	result
Men's 5000m	2016-08-20	1	0:13:03
Men's 10,000m	2016-08-13	1	0:27:05
Men's 5000m	2017-08-12	2	0:13:33
Men's 10,000m	2017-08-04	1	0:26:50
Men's 800m	2017-08-08	NULL	NULL
Men's Marathon	2019-10-05	NULL	NULL
Men's 100m	2017-08-05	NULL	NULL

Ejercicio #13: Mostrar los Nombres de las Competiciones y el Número de Eventos

Ejercicio: Mostrar todos los nombres de las competiciones y el número de eventos para cada competición.

Solución:

SELECT
  c.name AS competition_name,
  COUNT(*) AS events_held
FROM competition c
JOIN event e
  ON e.competition_id = c.id
GROUP BY c.name;

Explicación: Primero, muestre el nombre de la columna de la tabla competition y cambia el nombre de la columna a competition_name.

A continuación, utilice la función agregada COUNT(*) para contar el número de eventos celebrados. La función COUNT() con un asterisco contará todas las filas de la salida, incluidos los NULL. Para una mejor legibilidad, alias de la columna resultante como events_held.

Las tablas que unimos son competition y event. Por último, para obtener el número de eventos por competición, es necesario GROUP BY el nombre de la competición.

Resultado:

competition_name	events_held
IAAF World Championships in Athletics	15
Rio de Janeiro Olympic Games	16
London IAAF World Championships in Athletics	16

Ejercicio nº 14: Mostrar los nombres de los atletas más populares

Ejercicio: Mostrar los nombres de atletas más populares. Los nombres son populares si al menos cinco atletas los comparten. Junto al nombre, muestre también el número de atletas con ese nombre. Ordena los resultados de forma que los nombres más populares aparezcan en primer lugar.

Solución:

SELECT
  first_name,
  COUNT(*) AS name_count
FROM athlete
GROUP BY first_name
HAVING COUNT(*) >= 5
ORDER BY COUNT(*) DESC;

Explicación: Primero, selecciona los nombres de pila y cuéntalos utilizando COUNT(*). A continuación, agrupa por el nombre del atleta. Ahora tienes todos los nombres y su recuento.

Pero necesitas mostrar sólo los nombres con un recuento superior a cinco. Lo conseguirás utilizando la cláusula HAVING. Tiene el mismo uso que WHERE, pero HAVING se utiliza para filtrar datos agregados.

Por último, ordene la salida por el recuento de nombres de mayor a menor. No puede escribir simplemente el nombre de la columna name_count en ORDER BY porque la ordenación se realiza antes de la agregación; SQL no reconocerá el nombre de la columna. En su lugar, copie COUNT(*) y ordene de forma descendente.

Este ejercicio muestra un típico problema SQL que requiere filtrar datos con una función agregada.

Salida:

first_name	name_count
David	9
Daniel	7
Michael	7
Jessica	6
Alex	6
Sarah	5
Diana	5
Jonathan	5
Emmanuel	5
Isaac	5
Julian	5
Anna	5

Ejercicio #15: Mostrar cada país y el número de atletas que terminaron sin un puesto

Ejercicio: Mostrar todos los países con el número de sus atletas que terminaron sin un lugar. Mostrar 0 si ninguno. Ordene la salida en orden descendente por el número de atletas y en orden ascendente por el nombre del país.

Solución:

SELECT
  n.country_name,
  COUNT(fin.athlete_id) AS athletes_no
FROM nationality n
LEFT JOIN athlete a
  ON n.id = a.nationality_id
LEFT JOIN final_result fin
  ON a.id = fin.athlete_id
 AND fin.place IS NULL
GROUP BY n.country_name
ORDER BY
  COUNT(fin.athlete_id) DESC,
  n.country_name ASC;

Explicación: Tienes que mantener todas las filas de la nationality por lo que es necesario LEFT JOIN con la tabla athlete tabla. Lo haces donde id es igual a nationality_id. Luego, LEFT JOIN otra tabla donde id de la athlete es igual a athlete_id de la final_result tabla.

Como necesitas todas las filas de nacionalidad, no puedes usar la condición IS NULL en WHERE. Hay una solución: muévela a la cláusula ON, y obtendrás todos los valores donde el lugar sea NULL.

Ahora, puede seleccionar la columna country_name. Además, utiliza la función COUNT() en la columna athlete_id para obtener el número de atletas que terminaron sin plaza. No puedes usar COUNT(*) aquí porque contaría f, y necesitas el recuento de atletas concretos.

Para obtener el valor del recuento por país, agrupa la salida por nombre de país.

Por último, ordena la salida por el número de atletas de forma descendente y por el nombre del país de forma ascendente.

Resultado: Aquí están las cinco primeras filas de la salida:

country_name	athletes_no
Bahrain	8
Ethiopia	6
Turkey	6
Kenya	5
South Africa	5

Ejercicio #16: Calcular el Ritmo Medio de cada Carrera

Ejercicio: Calcular el ritmo medio de cada carrera y mostrarlo en la columna average_pace.

Solución:

SELECT fin.result / (d.distance * 1.0 / 1000) AS average_pace
FROM event e
JOIN discipline d
  ON e.discipline_id = d.id
JOIN final_result fin
  ON fin.event_id = e.id;

Explicación: Para obtener el ritmo promedio por carrera, necesita dividir el resultado por la distancia. Esto es lo que hace la consulta anterior, pero con dos ajustes.

En primer lugar, debe multiplicar la distancia por 1,0. Esto se hace para convertir la distancia en un número decimal. Sin eso, la división podría devolver un resultado diferente, ya que el resultado se dividirá por el número entero. El segundo ajuste es que divides la distancia por 1.000. Al hacer esto, convertirás la distancia de metros a kilómetros.

Ahora que ya tienes el cálculo, dale a esta columna el alias average_pace.

El resto de la consulta es lo que ya has visto en ejemplos anteriores: estás uniendo la tabla event con la tabla discipline y luego con la tabla final_result.

Resultado: Aquí están las primeras cinco filas de la salida:

average_pace
0:01:38
0:01:39
0:01:39
0:01:39
0:01:39

Ejemplo #17: Encontrar Todos los Tiempos Más Rápidos que el Promedio para Carreras de 1,500 Metros

Ejercicio: Obtenga los tiempos para todas las carreras de 1,500 metros. Muestre sólo los tiempos que son más rápidos que el tiempo promedio para esa carrera.

Solución:

SELECT fin.result
FROM final_result fin
JOIN event e
  ON fin.event_id = e.id
JOIN discipline d
  ON e.discipline_id = d.id
WHERE distance = 1500
  AND fin.result < (
    SELECT AVG(fin.result)
    FROM final_result fin
    JOIN event e
      ON fin.event_id = e.id
    JOIN discipline d
      ON e.discipline_id = d.id
    WHERE distance = 1500
  );

Explicación: Necesitas conocer las subconsultas SQL para resolver este ejercicio. Su definición básica es que son consultas dentro de una consulta principal. Veamos cómo funciona.

Selecciona la columna de resultados de la tabla final_result. A continuación, JOIN la tabla con event y luego con la discipline tabla.

Después, tienes que establecer dos condiciones en WHERE. La primera selecciona sólo distancias que sean iguales a 1.500.

La segunda busca datos cuyo resultado esté por debajo de la media total de carreras de 1.500 metros. Para calcular la media, utilice una subconsulta de la siguiente manera.

Entre los paréntesis después del operador de comparación, escriba otra sentencia SELECT ( es decir, una subconsulta). En ella, utilice la función de agregación AVG() para calcular el resultado medio. El resto de la consulta es igual que la consulta principal; está uniendo las mismas tablas y utilizando la misma condición de filtrado en WHERE.

Resultado: Aquí están las primeras filas de la salida:

result
0:03:51
0:03:51
0:03:51
0:03:51
0:03:51
0:03:50
0:03:50
0:03:51

Ejercicio #18: Encontrar Todos los Atletas que Corrieron al Menos Dos Pruebas en una Competición

Ejercicio: Obtenga una lista de los atletas que corrieron en dos o más pruebas dentro de una competición. Muestre sólo sus nombres y apellidos.

Solución:

SELECT
  first_name,
  last_name
FROM athlete
WHERE id IN (
  SELECT fin.athlete_id
  FROM event e
  JOIN final_result fin
    ON fin.event_id = e.id
  GROUP BY e.competition_id, fin.athlete_id
  HAVING COUNT(*) >= 2
);

Explicación: Comience seleccionando el nombre y el apellido de la tabla athlete.

A continuación, utilice WHERE para establecer una condición. Volvemos a utilizar una subconsulta para devolver los datos que queríamos comparar, esta vez con la columna id. Sin embargo, en el ejemplo anterior, utilizamos el operador "menor que" (<) porque la subconsulta sólo devolvía un valor. Esta vez, utilizamos el operador IN, que recorrerá todos los valores devueltos por la subconsulta y devolverá los que cumplan la condición.

La condición es que los atletas compitan en al menos dos pruebas dentro de una competición. Para encontrar esos atletas, seleccionamos la columna athlete_id y unimos las tablas event y final_result. A continuación, agrupe los resultados por los ID de competición y de atleta. Este ejemplo muestra que puede agrupar los resultados por la columna que no está en SELECT. Sin embargo, todas las columnas que aparecen en SELECT tienen que aparecer también en GROUP BY.

Por último, utilice HAVING para filtrar los datos. Cuente el número de filas utilizando COUNT(*). De esta forma, estarás contando cuántas veces aparece cada atleta. Establece la condición para que sólo aparezcan los atletas con un recuento igual o superior a dos.

Resultado: Esta es la captura de salida.

first_name	last_name
Usain	BOLT
André	DE GRASSE
Aaron	BROWN
LaShawn	MERRITT
Wayde	VAN NIEKERK

Ejercicio #19: Mostrar Corredores que Sólo Terminaron Primero

Ejercicio: Mostrar todos los corredores que nunca han terminado en otro lugar que no sea el primero; el lugar nunca faltó para ellos. Muestre tres columnas: id, first_name, y last_name.

Solución:

SELECT
  a.id,
  a.first_name,
  a.last_name
FROM athlete a
JOIN final_result fin
  ON a.id = fin.athlete_id
WHERE fin.place = 1

EXCEPT

SELECT
  a.id,
  a.first_name,
  a.last_name
FROM athlete a
JOIN final_result fin
  ON a.id = fin.athlete_id
WHERE fin.place != 1 OR fin.place IS NULL;

Explicación: Para esta solución, necesita utilizar el operador de conjunto EXCEPT. Los operadores de conjunto se utilizan para devolver los valores de dos o más consultas. EXCEPT devuelve todos los registros únicos de la primera consulta excepto los devueltos por la segunda consulta.

La primera consulta de la solución busca los atletas que terminaron en primer lugar. Para obtener estos valores, seleccione las columnas necesarias de la tabla athlete. A continuación, una la tabla con la tabla final_result. Después, establece la condición en WHERE para encontrar sólo los primeros puestos.

Ahora, escribe la palabra clave EXCEPT y síguela con la segunda consulta.

La segunda consulta es casi igual a la primera. La única diferencia son dos condiciones en WHERE.

La primera condición devuelve todos los lugares que no son el primero utilizando el operador "no igual" (!=). La segunda condición busca los puestos noNULL, es decir, el puesto nunca faltó para ese atleta. Las condiciones se conectan utilizando OR porque una de ellas tiene que ser cierta; el atleta no puede terminar por debajo del primer puesto y además no terminar.

Tenga en cuenta que para que los operadores de conjuntos funcionen, tiene que haber el mismo número de columnas del mismo tipo de datos en ambas consultas.

Salida:

id	first_name	last_name
14590785	Elijah Motonei	MANANGOI
14208194	Eliud	KIPCHOGE
14603138	Donavan	BRAZIER
14289014	Jemima Jelagat	SUMGONG
14536762	Noah	LYLES
14377814	Lelisa	DESISA
14209691	David	RUDISHA
14431159	Halimah	NAKAAYI

Ejercicio #20: Encontrar todos los atletas que no empezaron y que ganaron al menos una vez

Ejercicio: Obtenga los resultados de los atletas que no empezaron al menos una carrera y ganaron al menos una carrera. Muestre tres columnas: id, first_name, y last_name.

Solución:

SELECT
  a.id,
  a.first_name,
  a.last_name
FROM athlete a
JOIN final_result fin
  ON a.id = fin.athlete_id
WHERE fin.is_dns IS TRUE

INTERSECT

SELECT
  a.id,
  a.first_name,
  a.last_name
FROM athlete a
JOIN final_result fin
  ON a.id = fin.athlete_id
WHERE fin.place = 1;

Explicación: Este ejercicio utiliza otro operador de conjuntos. Esta vez, es INTERSECT, que devuelve todos los valores que son iguales en ambas consultas.

La primera consulta de la solución enumera los ID y los nombres y apellidos de los deportistas. Las tablas athlete y final_result se unen en las columnas id y athlete_id de las tablas.

La condición en WHERE busca filas con TRUE como valor en la columna is_dns, es decir, la columna que muestra si el atleta comenzó la carrera.

Como en el ejemplo anterior, escriba el operador set y luego la segunda consulta.

La segunda consulta es la misma que la primera, excepto WHERE. La condición de filtrado encontrará los atletas que terminaron en primer lugar.

Juntas, estas dos consultas dan como resultado los atletas que no empezaron la carrera al menos una vez, pero que también terminaron primeros al menos una vez.

Resultados:

id	first_name	last_name
14291986	Dafne	SCHIPPERS

De la Práctica Básica de Consultas SQL a Convertirse en un Maestro SQL

Hay que empezar por algún sitio. Estas 20 prácticas básicas de consultas SQL son ideales para sentar las bases antes de aprender conceptos más avanzados.

Aprendiste mucho mientras practicabas escribiendo consultas que usaban WHERE, ORDER BY, JOINs, GROUP BY, y HAVING. También te mostré varios ejemplos de cómo tratar con NULLs, hacer cómputos, escribir subconsultas y usar operadores de conjuntos. Las consultas de este artículo han sido tomadas de nuestro Basic Ejercicio de SQL: ¡Corre la pista a través de las consultas! Allí encontrarás más ejercicios de SQL básico. Y si quieres más práctica, echa un vistazo a nuestro Ejercicio de SQL pista, que contiene 9 cursos de práctica de SQL para principiantes.

Añade 20 ejemplos de consultas SQL básicas y 10 ejercicios de práctica SQL para principiantes a la mezcla, y estarás equipado con un nivel intermedio de competencia SQL.