Volver a la lista de artículos Artículos
Lectura de 25 minutos

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

Author's photo
Tihomir Babic

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.

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:

Práctica en línea de consultas SQL básicas

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.

idnamestart_dateend_dateyearlocation
7093747Rio de Janeiro Olympic Games2016-08-122016-08-212016Estádio Olímpico, Rio de Janeiro (BRA)
7093740London IAAF World Championships in Athletics2017-08-042017-08-132017Olympic Stadium, London (GBR)
7125365IAAF World Championships in Athletics2019-09-272019-10-062019Khalifa 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:

idnameis_mendistance
1Men's 100mTRUE100
2Men's 200mTRUE200
3Men's 400mTRUE400
4Men's 800mTRUE800
5Men's 1500mTRUE1,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:

idcompetition_iddiscipline_idfinal_datewind
1709374712016-08-140.2
2709374722016-08-18-0.5
3709374732016-08-140
4709374742016-08-150
5709374752016-08-200

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:

idfirst_namelast_namenationality_idbirth_date
14201847UsainBOLT11986-08-21
14238562JustinGATLIN21982-02-10
14535607AndréDE GRASSE31994-11-10
14201842YohanBLAKE11989-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:

idcountry_namecountry_abbr
1JamaicaJAM
2United StatesUSA
3CanadaCAN
4South AfricaRSA
5Côte d’IvoireCIV

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_idathlete_idresultplaceis_dsqis_dnsis_dnf
1142018470:00:101FALSEFALSEFALSE
1142385620:00:102FALSEFALSEFALSE
1145356070:00:103FALSEFALSEFALSE
1142018420:00:104FALSEFALSEFALSE
1144177630:00:105FALSEFALSEFALSE

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_datewind
2016-08-140.2
2016-08-18-0.5
2016-08-140
2016-08-150
2016-08-200

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:

idnameis_mendistance
8Men's MarathonTRUE42,195
16Women's MarathonFALSE42,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_idathlete_idresultplaceis_dsqis_dnsis_dnf
614464221NULLNULLTRUEFALSEFALSE
714530623NULLNULLFALSEFALSETRUE
714573513NULLNULLFALSEFALSETRUE
814167397NULLNULLFALSEFALSETRUE
814177784NULLNULLFALSEFALSETRUE

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_idathlete_idresultplaceis_dsqis_dnsis_dnf
1414451797NULLNULLFALSETRUEFALSE
1614296979NULLNULLFALSETRUEFALSE
1914176330NULLNULLFALSETRUEFALSE
2214367867NULLNULLFALSETRUEFALSE
2414219653NULLNULLFALSETRUEFALSE
2414225279NULLNULLFALSETRUEFALSE
3214751813NULLNULLFALSETRUEFALSE
4114291986NULLNULLFALSETRUEFALSE

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_namecountry_abbr
AfghanistanAFG
AlgeriaALG
American SamoaASA
AndorraAND
AngolaANG

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_namelast_name
ZsófiaERDÉLYI
ZouhairAWAD
ZoeyCLARK
ZoeHOBBS
ZoeBUCKMAN

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_namefirst_nameplace
BOLTUsain3
BOLTUsain1
BOLTUsain1
GATLINJustin2
GATLINJustin1

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_nameyeardiscipline_name
Rio de Janeiro Olympic Games2016Men's Marathon
Rio de Janeiro Olympic Games2016Women's Marathon
London IAAF World Championships in Athletics2017Men's Marathon
London IAAF World Championships in Athletics2017Women's Marathon
IAAF World Championships in Athletics2019Men'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_namefinal_dateplaceresult
Men's 5000m2016-08-2010:13:03
Men's 10,000m2016-08-1310:27:05
Men's 5000m2017-08-1220:13:33
Men's 10,000m2017-08-0410:26:50
Men's 800m2017-08-08NULLNULL
Men's Marathon2019-10-05NULLNULL
Men's 100m2017-08-05NULLNULL

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_nameevents_held
IAAF World Championships in Athletics15
Rio de Janeiro Olympic Games16
London IAAF World Championships in Athletics16

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_namename_count
David9
Daniel7
Michael7
Jessica6
Alex6
Sarah5
Diana5
Jonathan5
Emmanuel5
Isaac5
Julian5
Anna5

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_nameathletes_no
Bahrain8
Ethiopia6
Turkey6
Kenya5
South Africa5

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_namelast_name
UsainBOLT
AndréDE GRASSE
AaronBROWN
LaShawnMERRITT
WaydeVAN 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:

idfirst_namelast_name
14590785Elijah MotoneiMANANGOI
14208194EliudKIPCHOGE
14603138DonavanBRAZIER
14289014Jemima JelagatSUMGONG
14536762NoahLYLES
14377814LelisaDESISA
14209691DavidRUDISHA
14431159HalimahNAKAAYI

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:

idfirst_namelast_name
14291986DafneSCHIPPERS

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.

Tags:

También te pueden interesar