Ejercicios de SQL resueltos: 12 consultas de examen de menos a más (con la base de datos para practicar)

SQL se aprende escribiendo consultas contra una base de datos real y comprobando el resultado, no leyendo teoría. Aquí tienes doce ejercicios de SQL resueltos, ordenados de menos a más difíciles, todos sobre la misma base de datos pequeña que puedes copiar y ejecutar en dos minutos. Cada ejercicio tiene el enunciado, la consulta, el resultado exacto que debe salirte y la explicación de la trampa que suele hacer fallar.
Son las consultas que más se repiten en el módulo de Bases de datos de DAM y DAW, en Gestión de Bases de Datos de ASIR y ASIX y en las asignaturas de bases de datos de Ingeniería Informática: filtros, NULL, funciones de agregado, GROUP BY con HAVING, JOIN de tres tablas, LEFT JOIN, subconsultas y NOT EXISTS. Al final tienes dos ejercicios de UPDATE y DELETE y un método para enfrentarte a una consulta que no sabes por dónde coger.
La base de datos de los ejercicios
Una academia con profesores, cursos, alumnos y matrículas. Es pequeña a propósito: con pocas filas puedes comprobar a mano si el resultado es correcto, que es justo lo que tendrás que hacer en un examen en papel.
- Un profesor imparte varios cursos (1:N).
- Un alumno se matricula en varios cursos y un curso tiene varios alumnos (N:M), así que la relación se convierte en la tabla
matriculas, con su fecha y su nota. - Hay datos "incómodos" a propósito: una profesora sin cursos, un curso sin alumnos, una alumna sin matrículas, alumnos sin email y una nota todavía sin poner (
NULL). Son exactamente los casos que separan una consulta correcta de una que "casi funciona".
CREATE TABLE profesores (
id INT PRIMARY KEY,
nombre VARCHAR(50) NOT NULL,
ciudad VARCHAR(50)
);
CREATE TABLE cursos (
id INT PRIMARY KEY,
nombre VARCHAR(60) NOT NULL,
horas INT NOT NULL,
precio DECIMAL(6,2) NOT NULL,
profesor_id INT,
FOREIGN KEY (profesor_id) REFERENCES profesores(id)
);
CREATE TABLE alumnos (
id INT PRIMARY KEY,
nombre VARCHAR(50) NOT NULL,
apellido VARCHAR(50) NOT NULL,
ciudad VARCHAR(50),
fecha_nacimiento DATE,
email VARCHAR(100)
);
CREATE TABLE matriculas (
alumno_id INT,
curso_id INT,
fecha DATE NOT NULL,
nota DECIMAL(4,2),
PRIMARY KEY (alumno_id, curso_id),
FOREIGN KEY (alumno_id) REFERENCES alumnos(id),
FOREIGN KEY (curso_id) REFERENCES cursos(id)
);
INSERT INTO profesores VALUES
(1, 'Laura Gil', 'Barcelona'),
(2, 'Marc Soler', 'Madrid'),
(3, 'Ana Ruiz', 'Valencia');
INSERT INTO cursos VALUES
(1, 'Java desde cero', 60, 300.00, 1),
(2, 'Bases de datos SQL', 40, 200.00, 1),
(3, 'Python', 50, 250.00, 2),
(4, 'Desarrollo web', 80, 400.00, 2),
(5, 'Linux y Bash', 30, 150.00, 2);
INSERT INTO alumnos VALUES
(1, 'Pau', 'Martí', 'Barcelona', '2004-03-12', 'pau@mail.com'),
(2, 'Lucía', 'Pérez', 'Madrid', '2002-07-30', NULL),
(3, 'Jordi', 'Vidal', 'Barcelona', '2005-11-02', 'jordi@mail.com'),
(4, 'Sara', 'López', 'Valencia', '2003-01-15', 'sara@mail.com'),
(5, 'Hugo', 'Sanz', 'Madrid', '2005-09-09', NULL),
(6, 'Marta', 'Font', 'Girona', '2004-05-21', 'marta@mail.com');
INSERT INTO matriculas VALUES
(1, 1, '2026-09-15', 7.50),
(1, 2, '2026-09-15', 6.00),
(2, 1, '2026-09-20', 4.00),
(2, 3, '2026-10-01', 8.50),
(3, 1, '2026-09-18', 9.00),
(3, 4, '2026-10-05', NULL),
(4, 2, '2026-09-25', 5.50),
(4, 3, '2026-10-01', 3.50),
(5, 4, '2026-10-10', 6.50);
El script funciona tal cual en MySQL, MariaDB, PostgreSQL y SQLite. En Oracle, escribe las fechas como DATE '2004-03-12' y haz un INSERT por fila. Si no quieres instalar nada, pégalo en un editor online como DB Fiddle y elige MySQL 8.
Cómo usar estos ejercicios
- Ejecuta el script y haz un
SELECT * FROMde cada tabla. Ten las cuatro tablas delante mientras resuelves; en el examen en papel también las tendrás. - Escribe tu consulta antes de mirar la solución y compara tu resultado con el que aparece debajo. Si coincide, mira igualmente la explicación: a veces una consulta da bien con estos datos por casualidad.
- Haz la variación. Si te sale sin mirar nada, ese tipo de consulta está aprendido.
| Nº | Ejercicio | Qué practicas |
|---|---|---|
| 1 | Alumnos de una ciudad ordenados | WHERE, ORDER BY |
| 2 | Cursos por precio y horas | BETWEEN, AND |
| 3 | Alumnos sin email | IS NULL |
| 4 | Alumnos de dos ciudades nacidos antes de 2004 | IN, precedencia de AND y OR |
| 5 | Alumnos por ciudad | COUNT, GROUP BY |
| 6 | Nota media de cada curso | JOIN, AVG, ROUND, NULL en agregados |
| 7 | Cursos con al menos dos aprobados | WHERE frente a HAVING |
| 8 | Alumnos, cursos y notas | JOIN de tres tablas |
| 9 | Cursos de cada profesor, también los que no tienen | LEFT JOIN, COUNT(columna) |
| 10 | Alumnos sin ninguna matrícula | NOT EXISTS, LEFT JOIN ... IS NULL |
| 11 | Notas por encima de la media | Subconsulta escalar |
| 12 | Mejor alumno de cada curso | Subconsulta correlacionada |
Ejercicio 1: alumnos de una ciudad, ordenados
Enunciado. Muestra el nombre y el apellido de los alumnos de Barcelona, ordenados por apellido.
SELECT nombre, apellido
FROM alumnos
WHERE ciudad = 'Barcelona'
ORDER BY apellido;
Resultado:
| nombre | apellido |
|---|---|
| Pau | Martí |
| Jordi | Vidal |
Lo que hay que entender. El orden de escritura es siempre SELECT, FROM, WHERE, ORDER BY. Los textos van entre comillas simples; las comillas dobles en PostgreSQL y Oracle significan nombre de columna, no texto, y dan un error confuso. Sin ORDER BY no hay ningún orden garantizado, aunque parezca que las filas salen ordenadas.
Variación: los alumnos que no son de Barcelona, del más joven al más mayor (<> y ORDER BY fecha_nacimiento DESC).
Ejercicio 2: cursos por precio y horas
Enunciado. Muestra los cursos que cuestan entre 200 y 300 euros (ambos incluidos) y duran más de 45 horas.
SELECT nombre, horas, precio
FROM cursos
WHERE precio BETWEEN 200 AND 300
AND horas > 45;
Resultado:
| nombre | horas | precio |
|---|---|---|
| Java desde cero | 60 | 300.00 |
| Python | 50 | 250.00 |
Lo que hay que entender. BETWEEN incluye los dos extremos: el curso de 300 € sale. Bases de datos SQL cumple el precio (200 €) pero no las horas, y por eso no aparece. Si el enunciado dice "entre 200 y 300 sin incluirlos", usa precio > 200 AND precio < 300.
Ejercicio 3: alumnos sin email
Enunciado. Muestra los alumnos que no tienen email registrado.
SELECT nombre, apellido
FROM alumnos
WHERE email IS NULL;
Resultado:
| nombre | apellido |
|---|---|
| Lucía | Pérez |
| Hugo | Sanz |
Lo que hay que entender. WHERE email = NULL no da error, pero devuelve cero filas. NULL significa "valor desconocido" y cualquier comparación con él da desconocido, ni verdadero ni falso. Para preguntar por NULL se usa siempre IS NULL o IS NOT NULL. Este fallo cae en casi todos los exámenes.
Ejercicio 4: alumnos de dos ciudades nacidos antes de 2004
Enunciado. Muestra los alumnos de Madrid o de Valencia que nacieron antes de 2004.
SELECT nombre, apellido, ciudad, fecha_nacimiento
FROM alumnos
WHERE ciudad IN ('Madrid', 'Valencia')
AND fecha_nacimiento < '2004-01-01';
Resultado:
| nombre | apellido | ciudad | fecha_nacimiento |
|---|---|---|---|
| Lucía | Pérez | Madrid | 2002-07-30 |
| Sara | López | Valencia | 2003-01-15 |
Lo que hay que entender. Mucha gente escribe:
WHERE ciudad = 'Madrid' OR ciudad = 'Valencia' AND fecha_nacimiento < '2004-01-01'
y le sale también Hugo, que es de Madrid pero nació en 2005. AND se evalúa antes que OR, así que eso significa "de Madrid (cualquier fecha) o de Valencia y nacido antes de 2004". Se arregla con paréntesis, (ciudad = 'Madrid' OR ciudad = 'Valencia') AND ..., o con IN, que es más claro. Regla práctica: si mezclas AND y OR, pon paréntesis siempre.
Ejercicio 5: número de alumnos por ciudad
Enunciado. Muestra cuántos alumnos hay en cada ciudad, de más a menos. Si hay empate, por orden alfabético de ciudad.
SELECT ciudad, COUNT(*) AS total
FROM alumnos
GROUP BY ciudad
ORDER BY total DESC, ciudad;
Resultado:
| ciudad | total |
|---|---|
| Barcelona | 2 |
| Madrid | 2 |
| Girona | 1 |
| Valencia | 1 |
Lo que hay que entender. GROUP BY ciudad junta las filas que tienen la misma ciudad y COUNT(*) las cuenta dentro de cada grupo. La regla de oro: en el SELECT solo pueden ir columnas del GROUP BY o funciones de agregado (COUNT, SUM, AVG, MAX, MIN). Si añades nombre, MySQL con configuración antigua te deja y devuelve un nombre cualquiera del grupo; PostgreSQL, Oracle y MySQL 8 dan error. El profesor lo corrige como error.
Ejercicio 6: nota media de cada curso
Enunciado. Muestra el nombre de cada curso que tiene matrículas y la nota media de sus alumnos con dos decimales, de mayor a menor media.
SELECT c.nombre AS curso, ROUND(AVG(m.nota), 2) AS media
FROM cursos c
JOIN matriculas m ON m.curso_id = c.id
GROUP BY c.id, c.nombre
ORDER BY media DESC;
Resultado:
| curso | media |
|---|---|
| Java desde cero | 6.83 |
| Desarrollo web | 6.50 |
| Python | 6.00 |
| Bases de datos SQL | 5.75 |
Lo que hay que entender. Mira Desarrollo web: tiene dos matrículas, Hugo con un 6,5 y Jordi sin nota. La media sale 6,5, no 3,25, porque las funciones de agregado ignoran los NULL. Lo mismo pasa con COUNT(m.nota), que en ese curso da 1, mientras que COUNT(*) da 2. Si el enunciado quisiera contar la nota pendiente como un 0, tendrías que escribir AVG(COALESCE(m.nota, 0)).
Agrupar por c.id además de c.nombre evita mezclar dos cursos distintos que tuvieran el mismo nombre. Y Linux y Bash no sale porque el JOIN solo devuelve cursos que tienen alguna matrícula.
Ejercicio 7: cursos con al menos dos aprobados
Enunciado. Muestra los cursos que tienen dos o más alumnos aprobados (nota de 5 o más) y cuántos aprobados tiene cada uno.
SELECT c.nombre AS curso, COUNT(*) AS aprobados
FROM cursos c
JOIN matriculas m ON m.curso_id = c.id
WHERE m.nota >= 5
GROUP BY c.id, c.nombre
HAVING COUNT(*) >= 2;
Resultado:
| curso | aprobados |
|---|---|
| Java desde cero | 2 |
| Bases de datos SQL | 2 |
Lo que hay que entender. Esta consulta usa los dos filtros y en el orden correcto:
WHEREfiltra filas antes de agrupar. Aquí quita las matrículas suspendidas y las que no tienen nota.HAVINGfiltra grupos después de agrupar. Aquí quita los cursos con menos de dos aprobados.
Escribir WHERE COUNT(*) >= 2 da error, porque en el momento del WHERE todavía no hay grupos que contar. Si dudas, pregúntate: ¿esta condición habla de una fila o de un grupo?
Ejercicio 8: alumnos, cursos y notas
Enunciado. Muestra un listado con el nombre y apellido de cada alumno, el curso en el que está matriculado y su nota, ordenado por apellido y después por curso.
SELECT a.nombre, a.apellido, c.nombre AS curso, m.nota
FROM matriculas m
JOIN alumnos a ON a.id = m.alumno_id
JOIN cursos c ON c.id = m.curso_id
ORDER BY a.apellido, c.nombre;
Resultado:
| nombre | apellido | curso | nota |
|---|---|---|---|
| Sara | López | Bases de datos SQL | 5.50 |
| Sara | López | Python | 3.50 |
| Pau | Martí | Bases de datos SQL | 6.00 |
| Pau | Martí | Java desde cero | 7.50 |
| Lucía | Pérez | Java desde cero | 4.00 |
| Lucía | Pérez | Python | 8.50 |
| Hugo | Sanz | Desarrollo web | 6.50 |
| Jordi | Vidal | Desarrollo web | NULL |
| Jordi | Vidal | Java desde cero | 9.00 |
Lo que hay que entender. En una relación N:M la tabla intermedia es el centro: empieza por matriculas y únela a cada lado por su clave foránea. Cada JOIN necesita su ON; si olvidas uno, obtienes el producto cartesiano (cada matrícula combinada con todos los cursos) y el listado se dispara de 9 a 45 filas. Contar filas es la forma más rápida de detectar ese error.
Los alias (a, c, m) no son decoración: como alumnos y cursos tienen las dos una columna nombre, sin prefijo la consulta es ambigua y falla.
Ejercicio 9: cursos de cada profesor, también los que no tienen
Enunciado. Muestra todos los profesores con el número de cursos que imparten, incluidos los que no imparten ninguno.
SELECT p.nombre, COUNT(c.id) AS num_cursos
FROM profesores p
LEFT JOIN cursos c ON c.profesor_id = p.id
GROUP BY p.id, p.nombre
ORDER BY num_cursos DESC;
Resultado:
| nombre | num_cursos |
|---|---|
| Marc Soler | 3 |
| Laura Gil | 2 |
| Ana Ruiz | 0 |
Lo que hay que entender. Dos detalles que valen el punto entero del ejercicio:
LEFT JOIN, noJOIN. ConJOIN, Ana Ruiz desaparece porque no tiene cursos con los que emparejarse. ElLEFT JOINconserva todas las filas de la tabla de la izquierda y rellena conNULLlas columnas de la derecha.COUNT(c.id), noCOUNT(*). La fila de Ana existe (conc.idaNULL), así queCOUNT(*)le asignaría 1 curso.COUNT(c.id)no cuenta losNULLy da el 0 correcto.
Cuando el enunciado diga "todos", "incluidos los que no" o "aunque no tengan", piensa en LEFT JOIN.
Ejercicio 10: alumnos sin ninguna matrícula
Enunciado. Muestra los alumnos que no están matriculados en ningún curso.
SELECT a.nombre, a.apellido
FROM alumnos a
WHERE NOT EXISTS (
SELECT 1
FROM matriculas m
WHERE m.alumno_id = a.id
);
Resultado:
| nombre | apellido |
|---|---|
| Marta | Font |
Lo que hay que entender. NOT EXISTS se lee casi en castellano: "alumnos para los que no existe ninguna matrícula con su id". La subconsulta usa a.id de la consulta de fuera, así que se evalúa para cada alumno. Hay dos formas equivalentes que también se aceptan:
-- Con LEFT JOIN: los que se quedan sin pareja tienen NULL a la derecha
SELECT a.nombre, a.apellido
FROM alumnos a
LEFT JOIN matriculas m ON m.alumno_id = a.id
WHERE m.alumno_id IS NULL;
-- Con NOT IN
SELECT nombre, apellido
FROM alumnos
WHERE id NOT IN (SELECT alumno_id FROM matriculas);
Cuidado con NOT IN: si la subconsulta devuelve algún NULL, la consulta entera devuelve cero filas. Aquí no pasa porque alumno_id forma parte de la clave primaria y no puede ser NULL, pero con columnas que admiten nulos es una trampa clásica. Por eso NOT EXISTS es la opción más segura.
Ejercicio 11: notas por encima de la media
Enunciado. Muestra el alumno, el curso y la nota de las matrículas cuya nota supera la media de todas las notas, de mayor a menor.
SELECT a.nombre, a.apellido, c.nombre AS curso, m.nota
FROM matriculas m
JOIN alumnos a ON a.id = m.alumno_id
JOIN cursos c ON c.id = m.curso_id
WHERE m.nota > (SELECT AVG(nota) FROM matriculas)
ORDER BY m.nota DESC;
Resultado (la media general es 6,3125):
| nombre | apellido | curso | nota |
|---|---|---|---|
| Jordi | Vidal | Java desde cero | 9.00 |
| Lucía | Pérez | Python | 8.50 |
| Pau | Martí | Java desde cero | 7.50 |
| Hugo | Sanz | Desarrollo web | 6.50 |
Lo que hay que entender. No puedes escribir WHERE m.nota > AVG(m.nota): las funciones de agregado no se pueden usar en el WHERE. La solución es calcular la media aparte, en una subconsulta escalar (devuelve un único valor), y comparar con ella. Antes de escribir la consulta grande, ejecuta la subconsulta sola y comprueba que da 6,3125: es la forma de depurar consultas anidadas.
Ejercicio 12: mejor alumno de cada curso
Enunciado. Para cada curso con notas, muestra el alumno con la nota más alta y su nota. Si hay empate, deben salir todos los empatados.
SELECT c.nombre AS curso, a.nombre, a.apellido, m.nota
FROM matriculas m
JOIN alumnos a ON a.id = m.alumno_id
JOIN cursos c ON c.id = m.curso_id
WHERE m.nota = (
SELECT MAX(m2.nota)
FROM matriculas m2
WHERE m2.curso_id = m.curso_id
)
ORDER BY c.nombre;
Resultado:
| curso | nombre | apellido | nota |
|---|---|---|---|
| Bases de datos SQL | Pau | Martí | 6.00 |
| Desarrollo web | Hugo | Sanz | 6.50 |
| Java desde cero | Jordi | Vidal | 9.00 |
| Python | Lucía | Pérez | 8.50 |
Lo que hay que entender. Es el ejercicio que más suspende porque la idea intuitiva no funciona:
-- MAL: el nombre no está en el GROUP BY
SELECT curso_id, alumno_id, MAX(nota)
FROM matriculas
GROUP BY curso_id;
MAX te da la nota más alta del grupo, pero no "la fila" que la tiene, y alumno_id no puede ir en el SELECT sin estar en el GROUP BY. La solución es una subconsulta correlacionada: para cada matrícula m, calcula el máximo de su mismo curso (m2.curso_id = m.curso_id) y quédate con la fila si su nota coincide. Usar dos alias distintos de la misma tabla (m y m2) es lo que hace que funcione. Si dos alumnos empatan, salen los dos, que es lo que pide el enunciado.
En PostgreSQL, MySQL 8 y Oracle también se puede resolver con funciones de ventana (RANK() OVER (PARTITION BY curso_id ORDER BY nota DESC)), pero en los exámenes de ciclo y de primeros cursos de carrera suelen esperar la subconsulta.
Dos ejercicios de UPDATE y DELETE que caen siempre
Los UPDATE y DELETE tienen menos variedad, pero un error aquí borra o cambia datos de verdad. Antes de ejecutar uno, ejecuta un SELECT con el mismo WHERE y mira qué filas va a tocar.
Subir un 10 % el precio de los cursos que imparte Marc Soler (afecta a Python, Desarrollo web y Linux y Bash):
UPDATE cursos
SET precio = precio * 1.10
WHERE profesor_id = (SELECT id FROM profesores WHERE nombre = 'Marc Soler');
Borrar las matrículas que todavía no tienen nota (solo la de Jordi en Desarrollo web):
DELETE FROM matriculas
WHERE nota IS NULL;
Un UPDATE o DELETE sin WHERE afecta a toda la tabla. Y si intentas borrar un alumno que tiene matrículas, la clave foránea lo impide: primero se borran sus matrículas o se define la clave con ON DELETE CASCADE, que es justo lo que suelen preguntar en la parte teórica.
Un método para cualquier consulta de examen
Cuando un enunciado no te sale a la primera, no empieces por el SELECT. Resuélvelo en este orden:
- ¿Qué tablas tienen los datos que necesito? Subraya en el enunciado las columnas que se piden y las que se filtran, y localiza su tabla.
- ¿Cómo se unen? Sigue las claves foráneas. Si hay tabla intermedia, pasa por ella. Decide si es
JOINoLEFT JOIN("todos", "aunque no tengan"). - ¿Qué filas sobran? Eso va al
WHERE. - ¿Me piden algo "por cada"? Eso es
GROUP BY. Si además filtran por un total, una media o un recuento, esHAVING. - ¿Qué columnas muestro y en qué orden?
SELECTyORDER BY, lo último.
Y construye por capas: primero el FROM con los JOIN y un SELECT *, comprueba las filas; luego añade el WHERE, luego el GROUP BY. Si algo se rompe, sabes en qué capa ha sido. Tienes la parte de diseño (entidad-relación, paso a tablas y normalización) y los errores de SQL que más suspenden en Bases de datos en DAM y DAW, y consejos para el día del examen en cómo preparar un examen práctico de programación.
Cuándo pedir ayuda
Vas bien si resuelves los doce ejercicios sin mirar la solución y sabes explicar por qué el ejercicio 9 usa COUNT(c.id) y no COUNT(*). Merece la pena pedir ayuda cuando:
- Las consultas de una tabla te salen, pero en cuanto hay
JOINyGROUP BYjuntos te pierdes. - Te sale un resultado y no sabes si es el correcto.
- Tu examen incluye procedimientos, funciones o triggers y no sabes ni cómo empezar uno.
- Tienes la recuperación cerca y no sabes qué priorizar.
En nuestras clases de SQL online trabajamos con tus enunciados y con el gestor que usa tu centro (MySQL, Oracle o PostgreSQL): escribes tú las consultas y el profesor te guía hasta que el método te sale solo. Lo adaptamos al temario de DAM y DAW, ASIR y ASIX o la universidad. Clases uno a uno por videollamada a 25 € la hora, sin matrícula ni permanencia.
Preguntas frecuentes
¿Dónde puedo practicar SQL gratis?
Instala MySQL o MariaDB con un cliente como DBeaver o MySQL Workbench, o usa SQLite, que no necesita servidor. Si no quieres instalar nada, un editor online como DB Fiddle te deja pegar el script de esta página y ejecutar consultas al momento. Lo importante es practicar con una base de datos cuyos datos conozcas, para poder comprobar si el resultado es el correcto.
¿Cuál es la diferencia entre WHERE y HAVING?
WHERE filtra filas antes de agrupar y no puede usar funciones de agregado. HAVING filtra grupos después del GROUP BY y sí puede usarlas. En el ejercicio 7 tienes los dos en la misma consulta.
¿Cuándo uso JOIN y cuándo LEFT JOIN?
JOIN devuelve solo las filas que tienen pareja en las dos tablas. LEFT JOIN devuelve todas las de la tabla izquierda, tengan pareja o no. Si el enunciado dice "todos", "incluidos los que no tienen" o te pide encontrar los que no tienen pareja, es LEFT JOIN.
¿Es lo mismo SQL en MySQL, Oracle y PostgreSQL?
Las consultas básicas (SELECT, JOIN, GROUP BY, subconsultas) son iguales en todos. Cambian los tipos de datos, el manejo de fechas, cómo limitar resultados (LIMIT en MySQL y PostgreSQL, FETCH FIRST en Oracle) y sobre todo la programación de procedimientos y triggers. Los doce ejercicios de esta página funcionan igual en todos.
¿Cuánto se tarda en aprender SQL para aprobar?
Las consultas de una tabla se dominan en pocos días. JOIN, GROUP BY y subconsultas necesitan unas semanas de práctica regular, haciendo ejercicios nuevos y no releyendo los resueltos. Si empiezas desde cero sin haber programado nunca, tienes una ruta general en cómo aprender programación desde cero.
¿SQL entra en ASIR y en la universidad igual que en DAM?
Sí, el núcleo es el mismo. En ASIR y ASIX se añade más administración (usuarios, permisos, copias de seguridad) y en la universidad más teoría (álgebra relacional, normalización formal, transacciones). Las consultas de esta página son la base de todos.