22 Ejercicios para Practicar Comandos SQL

¿Quieres mejorar tus conocimientos de SQL? Practica los comandos SQL en estos 22 ejercicios realistas.

Hay un viejo dicho que dice que "no hay sustituto para la experiencia". Pero, ¿cómo puedes conseguir esa experiencia cuando estás empezando a aprender algo nuevo? Lo mejor es practicar, practicar y practicar. En este artículo, te proporcionaremos algunas prácticas reales de comandos SQL.

Todos nuestros ejercicios de práctica están tomados de cursos en LearnSQL.es. Ofrecemos cursos interactivos de SQL en diferentes temas. Algunos cursos están dirigidos a principiantes; nuestro SQL para principiantes incluye más de 120 ejercicios sobre comandos SQL básicos. Los usuarios intermedios pueden beneficiarse de cursos como Ejercicio de SQLque incluye diez cursos interactivos y más de 100 horas de práctica. Y para los profesionales con experiencia, los tres cursos de la pista SQL avanzado (con casi 400 ejercicios prácticos) ayudarán a dominar las funciones más profundas de SQL.

Empecemos a mejorar nuestro conocimiento de los comandos SQL.

Trabajando con una Tabla: SELECT, WHERE, ORDENAR POR, AGRUPAR POR

En los próximos ejercicios, consultaremos datos de una única tabla que contiene información sobre gatos. La tabla se llama Cat y tiene las siguientes columnas

• id - El ID de un gato determinado. Es la clave principal de la tabla.
• name - El nombre del gato
• breed - El gato
• coloration - El gato
• age - El gato
• sex - El gato
• fav_toy - El juguete favorito del gato

Ejercicio nº 1: Selección de columnas y filtrado de datos numéricos

Ejercicio: Seleccionar el nombre, la raza y la coloración de todos los gatos menores de cinco años.

Solución:

SELECT 
  name, 
  breed, 
  coloration
FROM cat
WHERE age < 5;

Explicación: Enumere las columnas requeridas (name, breed, y coloration) en la cláusula SELECT; sepárelas con comas. Haga referencia a la tabla Cat en la cláusula FROM y utilice la condición requerida age < 5 en la cláusula WHERE.

Ejercicio nº 2: Selección de Todas las Columnas y Filtrado de Datos de Texto

Ejercicio: Seleccione todos los datos de los gatos cuya:

• La raza empieza por 'R
• El juguete favorito empieza por la palabra 'pelota'.
• La coloración termina con 'm'.

Solución:

SELECT *
FROM cat
WHERE breed LIKE 'R%'
  AND fav_toy LIKE 'ball%'
  AND coloration LIKE '%m';

Explicación: Como queremos obtener todas las columnas de la tabla en el resultado, utilizamos el símbolo * para representar todas las columnas disponibles en la tabla. Hacemos referencia a la Cat en la cláusula FROM e incluimos las tres condiciones de filtro necesarias utilizando el operador LIKE y el comodín %. El uso del operador AND significa que cada condición está relacionada con la anterior; las tres deben ser verdaderas para que la fila se incluya en el resultado.

Recuerde que los valores de texto deben ir entre comillas simples.

Ejercicio nº 3: Selección de columnas y filtrado de datos NULL

Ejercicio: Seleccionar los nombres de todos los gatos machos que no tienen un juguete favorito - es decir, el valor del campo fav_toy es NULL para estos gatos.

Solución:

SELECT name
FROM cat
WHERE sex = 'M'
  AND fav_toy IS NULL;

Explicación: Incluya sólo la columna nombre en la cláusula SELECT. Utilice dos condiciones de filtro con el operador AND en la cláusula WHERE. La primera condición consiste en hacer coincidir la columna sex con el literal 'M'. La segunda condición filtra las filas en las que la columna fav_toy tiene un valor NULL.

Importante: No puede comparar NULLs con otros valores usando operadores de comparación como equal; necesita preguntar si un valor ES NULL o NO ES NULL.

Ejercicio nº 4: Ordenando los Datos Devueltos por un SELECT

Ejercicio: Seleccione el nombre, edad, raza y sexo de todos los gatos, mostrando primero los más viejos.

Solución:

SELECT 
  name, 
  age, 
  breed, 
  sex
FROM cat
ORDER BY age DESC;

Explicación: Enumere las columnas requeridas (name, age, breed, y sex) en la cláusula SELECT. Haga referencia a la tabla Cat en la cláusula FROM y ordene las filas mediante la cláusula ORDER BY< seguida de la columna de edad.

Como el orden predeterminado es ascendente, debemos incluir la palabra clave opcional DESC para ordenar los datos en orden descendente, es decir, recuperar primero los gatos más viejos.

Ejercicio nº 5: Agrupación de datos y ordenación por agregación

Ejercicio: Mostrar el recuento de gatos por cada tipo de coloración, utilizando number_of_cats como alias para la función de agregación que calcula esa información. Muestre primero las coloraciones con menos gatos.

Solución:

SELECT 
  coloration, 
  COUNT(*) AS number_of_cats
FROM cat
GROUP BY coloration
ORDER BY number_of_cats DESC;

Explicación: Incluya la columna de coloración y la función agregada COUNT(*) en la cláusula SELECT. Utilice el alias AS number_of_cats para devolver un nombre fácil de usar a la columna COUNT(*).

Utilice la cláusula GROUP BY seguida de la columna coloration para agrupar los datos en función de la coloración. Ordene los resultados con la cláusula ORDER BY seguida de un nombre de columna o alias - en este caso, number_of_cats.

Ejercicio nº 6: Agrupación de Datos y Filtrado por Agregación

Ejercicio: Muestre la edad media de los gatos de cada raza; utilice Average_Age como alias para la función de agregación. Muestre sólo las razas en las que la edad media sea superior a cinco años.

Solución:

SELECT 
  breed, 
  AVG(age) AS Average_Age
FROM cat
GROUP BY breed
HAVING AVG(age) > 5;

Explicación: Incluya la columna de raza y la función agregada AVG(age) en la cláusula SELECT. Utilice un alias para devolver un nombre de columna fácil de usar para la función de agregado. Utilice la cláusula GROUP BY seguida de la columna de raza para agrupar los datos en función de cada raza de gato.

Como necesitamos filtrar basándonos en los resultados de la agregación, no podemos utilizar la cláusula WHERE; filtra las filas BEFORE que están agrupadas. En su lugar, debemos utilizar la cláusula HAVING; se aplica después de agrupar las filas.

Más información: Encuentre más ejemplos prácticos GROUP BY en el artículo 10 Ejercicios GROUP BY Ejercicio de SQL con Soluciones.

Trabajando con Tablas Múltiples: JOIN

En los próximos ejercicios, consultaremos datos de más de una tabla. Utilizaremos un modelo muy simple que incluye empleados, salarios y beneficios.

Veamos la employee estructura de la tabla:

• id - El id de un empleado determinado.
• first_name - El nombre del empleado.
• last_name - El apellido del empleado.
• salary - El del empleado.
• manager_id - El ID del responsable del empleado.

A continuación, la tabla salgrade guarda información sobre el grado salarial:

• Grado - El grado de un salario.
• lower_limit - El límite inferior del grado salarial.
• upper_limit - El límite superior del grado salarial.

Y la última tabla, benefitssólo tiene dos columnas:

• benefit_name - El nombre de una determinada prestación.
• salary_req - El salario mínimo requerido para obtener este beneficio.

Ejercicio nº 7: Unir implícitamente datos de varias tablas

Ejercicio: Seleccione el nombre, apellidos, salario y grado salarial de los empleados cuyo salario se encuentre entre lower_limit y upper_limit en la tabla salgrade tabla.

Solución:

SELECT 
  first_name, 
  last_name, 
  salary, 
  grade
FROM employee, salgrade
WHERE salary BETWEEN lower_limit AND upper_limit;

Explicación: Enumere las columnas requeridas (first_name, last_name, salary, grade) en la cláusula SELECT. Haga referencia tanto a la cláusula employee y salgrade en la cláusula FROM. Estamos utilizando la cláusula WHERE para definir los criterios de unión entre las dos tablas, especificando que el salario del empleado debe estar entre los límites inferior y superior de la tabla salgrade de la tabla.

Ejercicio nº 8: Unión Explícita de Datos de Múltiples Tablas

Ejercicio: Muestre todos los beneficios que recibiría el empleado con id = 5. Seleccione el nombre y apellidos de dicho empleado junto con los nombres de las prestaciones.

Solución:

SELECT 
  first_name, 
  last_name, 
  benefits.benefit_name
FROM employee
JOIN benefits 
ON employee.salary > benefits.salary_req
WHERE employee.id = 5;

Explicación: Enumere las columnas requeridas (first_name, last_name, benefits.benefit_name) en la cláusula SELECT. Haga referencia a la tabla employee en la cláusula FROM y, a continuación, una explícitamente las filas a la tabla de prestaciones mediante la palabra clave JOIN.

La condición que define la relación entre las dos tablas se especifica después de la palabra clave ON. De este modo, las condiciones de relación entre las tablas se mantienen separadas de las condiciones de filtrado, lo que mejora la claridad de la consulta. Las condiciones de filtrado se siguen definiendo en la cláusula WHERE; en este caso, utilizamos la condición employee.id = 5.

Ejercicio nº 9: Unir y Agrupar Datos de Múltiples Tablas

Ejercicio: Para cada beneficio, encuentre el número de empleados que lo reciben. Muestre dos columnas: la benefit_name y el número de empleados que la reciben (nombre esa columna employee_count). No te olvides de las prestaciones que no recibe nadie.

Solución:

SELECT 
  benefits.benefit_name, 
  COUNT(employee.id) AS employee_count
FROM benefits
LEFT JOIN employee 
ON salary_req <= employee.salary
GROUP BY benefits.benefit_name;

Explicación: Incluya la columna benefit_name y la función de agregación COUNT() (aplicada a la columna employee.id ) en la cláusula SELECT. Utilice un alias para los resultados de la función de agregación: AS employee_count. Haga referencia a la tabla benefits en la cláusula FROM y, a continuación, únase a la tabla employee tabla utilizando una LEFT JOIN.

Recuerde que las operaciones LEFT (y RIGHT) JOIN recuperan todos los datos del lado izquierdo (o derecho) de los criterios JOIN - incluso si no existen filas coincidentes en la otra tabla. Puede obtener más información en el artículo Explicación de los tipos de JOIN de SQL.

El criterio de unión se especifica después de la palabra clave ON. Finalmente, utilice la cláusula GROUP BY para agregar los datos al nivel benefit_name.

Ejercicio nº 10: Uniendo una Tabla a Si Misma (Self-Joins)

Ejercicio: Muestre el nombre, apellido, salario de cada empleado y el nombre y apellido de su jefe directo en la misma fila. Para los empleados que no tienen jefe (por ejemplo, el director general), muestre NULL como nombre y apellidos del jefe.

Utilice un alias para preceder las columnas de los empleados con employee_ y las de los directivos con manager_ (por ejemplo, employee_first_name).

Solución:

SELECT 
  e.first_name AS employee_first_name, 
  e.last_name AS employee_last_name, 
  e.salary AS employee_salary,
  m.first_name AS manager_first_name,
  m.last_name AS manager_last_name
FROM employee e
LEFT JOIN employee m 
ON e.manager_id = m.id;

Explicación: Incluya el nombre, los apellidos y el salario del empleado utilizando e como alias de la tabla. employee alias de la tabla. Incluya el nombre y apellidos del gerente utilizando m como alias de tabla. En la cláusula FROM, utilice la tabla employee con el alias e para hacer referencia a los datos de los empleados; en la cláusula LEFT JOIN, utilice la tabla employee tabla con el alias m para hacer referencia a la información del gerente. La condición de unión es que el valor manager_id del empleado debe coincidir con el valor id del gestor.

Más información: Unir una tabla a sí misma es una operación común. Puede parecer complicada, pero es más fácil de entender cuando se utilizan los alias adecuados para la tabla en cuestión. Para más ayuda con JOINs, vea nuestro curso SQL JOINS. Tiene más de 90 ejercicios interactivos, incluyendo diez ejemplos gratuitos para que empiece a practicar ahora mismo.

Usando Sub-Consultas

En esta sección, vamos a utilizar subconsultas para consultar datos basados en condiciones que dependen de otros datos almacenados en la base de datos. Utilizaremos las siguientes tablas, empezando por la tabla orchestras tabla:

• id - El ID de la orquesta.
• name - El nombre de la orquesta.
• rating - Puntuación de la orquesta en los últimos diez años.
• city_origin - La ciudad de origen de la orquesta (por ejemplo, "Berlín" para la Filarmónica de Berlín).
• country_origin - País de origen de la orquesta (por ejemplo, "Alemania" para la Filarmónica de Berlín).
• Año - Año de creación de la orquesta.

La tabla concert contiene información sobre los conciertos interpretados por las orquestas:

• id - El ID del concierto.
• city - El nombre de la ciudad donde tuvo lugar el concierto. Puede ser diferente de la ciudad de origen de la orquesta.
• country - El nombre del país donde tuvo lugar el concierto.
• year - El año en que se celebró el concierto.
• rating - La puntuación que los críticos dieron al concierto.
• orchestra_id - Identificación de la orquesta que interpretó el concierto.

La tabla members mantiene información sobre cada miembro de la orquesta:

• id - El ID de un miembro determinado.
• name - El nombre del miembro.
• position - La posición del miembro en la orquesta (por ejemplo, segunda flauta, viola principal).
• wage - Una mensualidad fija que se paga al miembro de la orquesta.
• experience - El número de años de experiencia que tiene este miembro de la orquesta.
• orchestra_id - El número de identificación de la orquesta.

Ejercicio nº 11: Uso de Subconsultas para Filtrar Datos

Ejercicio: Mostrar los nombres de las orquestas que fueron creadas después de la 'Orquesta de Cámara' y tienen una calificación mayor a 7.5.

Solución:

SELECT name
FROM orchestras 
WHERE year > 
(SELECT year 
FROM orchestras 
WHERE name = 'Chamber Orchestra') 
  AND rating > 7.5;

Explicación: Las cláusulas SELECT y FROM de este ejercicio son muy sencillas, pero la parte complicada es la cláusula WHERE. Tenemos dos condiciones que evaluar, y conocemos exactamente una de ellas (rating > 7.5). La segunda la desconocemos, ya que no es un valor definido como 7,5, sino algo que hay que obtener de los datos, es decir, el año de fundación de la Orquesta de Cámara.

En estos casos, utilizamos una subconsulta, es decir, una consulta que se ejecuta "dentro" de una consulta mayor. Este ejercicio requiere una subconsulta que obtenga el año de fundación de la orquesta cuyo nombre sea igual a "Orquesta de Cámara". Utilizaremos el resultado de esa subconsulta para filtrar el año de fundación de cada orquesta.

Consejo profesional: Cuando se trabaja con subconsultas, es una buena práctica empezar a construir primero la subconsulta. Una vez que devuelva el resultado deseado, ¡incrústelo en la consulta principal!

Ejercicio nº 12: Uso de Subconsultas en FROM

Ejercicio: Encontrar el número medio de miembros por orquesta.

Solución:

SELECT AVG(d.count) 
FROM (SELECT 
        orchestra_id, 
        COUNT(id) 
FROM members 
GROUP BY orchestra_id) d;

Explicación: Comience con la subconsulta obteniendo el conteo de miembros por cada orquesta y el identificador de la orquesta. Coloque la subconsulta en la cláusula FROM de la consulta principal y dele un alias. La cláusula SELECT sólo necesita calcular el número medio de miembros utilizando la función agregada AVG() sobre los resultados del recuento de la subconsulta.

Ejercicio nº 13: Subconsultas Correlacionadas

Ejercicio: Seleccionar el nombre, salario y experiencia de los miembros mejor pagados de cada orquesta.

Solución:

SELECT 
  name, 
  wage, 
  experience
FROM members m1
WHERE wage = (SELECT MAX(wage) 
             FROM members m2 
		WHERE m1.orchestra_id = m2.orchestra_id);

Explicación: Incluya las columnas name, wage, y experience en la cláusula principal SELECT. Ponga la tabla members en la cláusula FROM con el alias m1. En la cláusula WHERE, compare el valor del salario (de la consulta principal) con los resultados de la subconsulta correlacionada.

La subconsulta correlacionada obtiene el salario máximo utilizando la función agregada MAX() para todas las filas de la tabla de miembros (con el alias m2) donde el orchestra_id coincide con el de la consulta principal.

A diferencia de las subconsultas normales, que se ejecutan una vez antes de la consulta principal, las subconsultas correlacionadas se ejecutan una vez por cada fila de la consulta principal. Esto se debe a que hacen referencia a valores de la consulta principal.

Ejercicio nº 14: Uso de Filtros, Joins, GROUP BY y Subconsultas

Ejercicio: Para cada orquesta, muestre su nombre, el nombre de la ciudad donde la orquesta recibió la calificación más alta por su actuación, y esa calificación.

Solución:

SELECT 
  o.name, 
  c.city, 
  c.rating
FROM orchestras o
JOIN concerts c 
ON o.id = c.orchestra_id
WHERE c.rating IN ( SELECT MAX(con.rating)
			FROM concerts con
			WHERE con.orchestra_id = o.id) ;

Explicación: Incluya el nombre de la orquesta, el concierto city, y las columnas rating en la cláusula SELECT de la consulta principal. En la cláusula FROM, incluya la tabla orchestras y JOIN la tabla concerts tabla utilizando los ID de orquesta.

Utilice la cláusula WHERE para igualar el valor de concert rating con la valoración máxima del concierto obtenida por la orquesta. Para obtenerlo, utilice una subconsulta correlacionada que aplique la función MAX() a la columna de calificación. En la cláusula WHERE de la subconsulta, haga coincidir el ID de la orquesta del concierto con el ID de la orquesta de la consulta principal.

Comandos SQL de modificación de datos: INSERTAR, ACTUALIZAR, BORRAR

En las secciones anteriores, hemos utilizado el comando SELECT. En esta sección, practicaremos el uso de otros comandos SQL como INSERT, UPDATE, y DELETE. Utilizaremos la tabla dish que contiene información sobre las comidas de un restaurante. Tiene las siguientes columnas:

• id - El ID de cada plato y la clave primaria de esta tabla.
• type - El tipo de plato (por ejemplo, entrante, plato principal, postre).
• name - El nombre del plato.
• price - El nombre del plato

Ejercicio nº 15: Insertar una única fila sin especificar columnas

Ejercicio: Añadir un plato llamado Cevapcici con un ID de 9 y un precio de 27. Es un plato principal.

Solución:

INSERT INTO dish 
VALUES (9, 'main course', 'Cevapcici', 27);

Explicación: La cláusula INSERT INTO, seguida del nombre de la tabla, indica la tabla en la que queremos insertar datos. Como no proporcionamos una lista de columnas, los valores de todas las columnas deben proporcionarse en la cláusula VALUES. Enumérelos en el orden en que están definidos en la tabla y encierre la lista entre corchetes. En este caso, estamos insertando el ID, tipo, nombre y precio del plato en la tabla.

Ejercicio nº 16: Inserción de una única fila y especificación de columnas

Ejercicio: La cocina balcánica se está haciendo popular, así que necesitamos otro plato balcánico en el menú. Añadimos Pan de Kosovo con un ID de 10; es un entrante. Aún no hemos decidido el precio, así que omitámoslo por ahora.

Solución:

INSERT INTO dish (id, type, name) 
VALUES (10, 'starter', 'Kosovo Bread');

Explicación: Después de la cláusula INSERT INTO y del nombre de la tabla, coloque la lista de columnas que desea insertar. (¡Recuerde los corchetes!) A las columnas no incluidas en la lista se les asignará un valor NULL.

En la cláusula VALUES, se proporcionan valores para cada una de las columnas especificadas en la lista.

Ejercicio nº 17: Actualización de Determinadas Filas

Ejercicio: ¡Es la hora feliz en nuestro restaurante! Cambiar el precio de todos los platos principales a 20.

Solución:

UPDATE dish 
SET price = 20 
WHERE type = 'main course';

Explicación: Utilice la cláusula UPDATE seguida del nombre de la tabla que desea actualizar. En la cláusula SET, especifique la columna que desea actualizar (en este caso, sólo price) seguida del nuevo valor que desea asignarle.

La cláusula WHERE funciona de la misma manera que la sentencia SELECT, pero aquí identifica las filas a actualizar en lugar de las filas a devolver.

Ejercicio nº 18: Actualización de múltiples columnas

Ejercicio: Los rollitos de primavera se venden como locos, pero la ensalada de gambas (ID 1) ya no interesa a nadie. Tenemos que cambiarle el nombre por algo más exótico - probemos con Dragón Verde Marino. Fije el precio en 10 para animar a los clientes a probar este plato.

Solución:

UPDATE dish 
SET name = 'Green Sea Dragon', price = 10 
WHERE id = 1;

Explicación: Utilice la cláusula UPDATE seguida del nombre de la tabla que desea actualizar. En la cláusula SET, especifique las columnas que desea actualizar (name y price) seguidas del nuevo valor o valores que estamos asignando; separe cada par de nombre y valores con una coma. La cláusula WHERE funciona de la misma manera que la sentencia SELECT.

Ejercicio nº 19: Eliminación de una única fila

Ejercicio: Las Ostras Bienville (ID 7) no son muy populares. Eliminémoslas del menú.

Solución:

DELETE FROM dish 
WHERE id = 7;

Explicación: Utilice la cláusula DELETE FROM seguida del nombre de la tabla para indicar la tabla en la que se eliminarán los datos.

La cláusula WHERE funciona del mismo modo con DELETE que con SELECT. En este caso, compara la columna id con un único valor. Por lo tanto, sólo se borrarán una o cero filas (dependiendo de si la fila con id = 7 existe o no.

Ejercicio nº 20: Borrado de múltiples filas

Ejercicio: ¡Uy, nos hemos quedado sin azúcar! Eliminar todos los postres de nuestro menú.

Solución:

DELETE FROM dish 
WHERE type = 'dessert';

Explicación: Utilice la cláusula DELETE FROM seguida del nombre de la tabla para indicar la tabla en la que se eliminarán los datos. La cláusula WHERE funciona del mismo modo que el comando SELECT; en este caso, el comando SQL eliminará todas las filas con el valor "postre" en la columna de tipo.

Más información: Eche un vistazo al curso Cómo añadir, modificar y eliminar datos con SQL con más de 50 ejercicios sobre inserción, actualización y eliminación de datos.

Comandos CREATE TABLE y ALTER TABLE

Ahora podemos practicar el uso de dos comandos SQL adicionales que nos permiten crear y alterar tablas.

Ejercicio nº 21: Creación de una Tabla Simple

Ejercicio: Crear una tabla llamada result con dos columnas INTEGER (id y score) y una columna DATE (score_date).

Solución:

CREATE TABLE result (
  id integer,
  score integer,
  score_date date
);

Explicación: Utilice la sentencia CREATE TABLE seguida del nombre de la tabla que desea crear. Proporcione una lista de nombres de columnas con el tipo de datos adecuado, separados por comas. Asegúrese de que toda la lista de columnas está entre paréntesis.

Ejercicio nº 22: Agregar una Columna NOT NULL

Ejercicio: Modifique la tabla result haciendo que la columna id sea NOT NULL y agregando una nueva columna VARCHAR llamada nombre con un límite de 32 caracteres.

Solución:

ALTER TABLE result ALTER COLUMN id SET NOT NULL;
ALTER TABLE result ADD COLUMN name varchar(32);

Explicación: Utilice el comando ALTER TABLE seguido del nombre de la tabla. Utilice la cláusula ALTER COLUMN seguida del nombre de la columna que desea modificar. En este caso, establezca la columna como NOT NULL.

Vuelva a utilizar el comando ALTER TABLE. Esta vez, ponga la cláusula ADD COLUMN seguida del nombre de la nueva columna y su tipo de datos y límite de caracteres (varchar(32)).

Más información: El curso Los fundamentos de la creación de tablas en SQL incluye más de 80 ejercicios y 10 horas de práctica sobre la creación y modificación de tablas de bases de datos.

¿Listo para Más Práctica de Comandos SQL?

Hemos cubierto los comandos SQL que te permiten consultar una o varias tablas, filtrar datos, agrupar y ordenar datos, insertar y actualizar datos, y eliminar datos. También le hemos mostrado opciones básicas para crear y alterar tablas de bases de datos.

Sin embargo, aún queda mucho por saber sobre los comandos SQL. Echa un vistazo a Tu Guía a Ejercicio de SQL en LearnSQL. com para encontrar docenas de artículos que proporcionan práctica adicional de comandos SQL.

Para un aprendizaje completo, considere la compra de nuestro Paquete SQLTodo, para siempre . Este paquete le otorga acceso a todos los cursos actuales y futuros, garantizándole los recursos necesarios para mejorar continuamente sus conocimientos de SQL. No pierda esta oportunidad de mantenerse a la vanguardia.