Cheat sheet de SQL para entrevistas
Orden de ejecución, joins, funciones de ventana, NULL, índices y las consultas clásicas de entrevista, cada una con las filas que devolvió SQLite.
Actualizado el 10 consultas de entrevista55 resultados, cada uno ejecutado en SQLiteSe imprime limpia: usa la impresión de tu navegador
Cada resultado de esta página es lo que devolvió SQLite al ejecutar la consulta de arriba sobre las pequeñas tablas de ejemplo de abajo. La sintaxis es SQL estándar salvo que una fila diga lo contrario; donde PostgreSQL o MySQL se comportan distinto, la fila lo indica.
Tablas de ejemplo
Una empresa pequeña. Los joins usan sus propias dos tablas, que se muestran ahí.
| id | name | dept | salary | manager_id |
|---|---|---|---|---|
| 1 | Ana | eng | 120 | NULL |
| 2 | Ben | eng | 95 | 1 |
| 3 | Cleo | eng | 130 | 1 |
| 4 | Dev | ops | 95 | 1 |
| 5 | Eve | ops | 80 | 4 |
| 6 | Finn | ops | 100 | 4 |
| 7 | Gus | eng | 95 | 3 |
| id | name |
|---|---|
| 1 | Ivy |
| 2 | Jon |
| 3 | Kai |
| id | customer_id | amount |
|---|---|---|
| 1 | 1 | 30 |
| 2 | 1 | 40 |
| 3 | 3 | 25 |
| 4 | NULL | 10 |
| id | |
|---|---|
| 1 | a@x.io |
| 2 | b@x.io |
| 3 | a@x.io |
| 4 | c@x.io |
| 5 | b@x.io |
| 6 | a@x.io |
| day | amount |
|---|---|
| 2026-09-01 | 40 |
| 2026-09-02 | 55 |
| 2026-09-03 | 35 |
| 2026-09-04 | 55 |
| person | day |
|---|---|
| kim | 2026-09-01 |
| kim | 2026-09-02 |
| kim | 2026-09-03 |
| kim | 2026-09-05 |
| lou | 2026-09-01 |
| lou | 2026-09-03 |
| lou | 2026-09-04 |
| n |
|---|
| 1 |
| 2 |
| 3 |
| 5 |
| 6 |
| 9 |
Orden de ejecución
SELECT se escribe primero y se evalúa en quinto lugar. El orden lógico decide qué puede ver cada cláusula; el planificador puede ejecutarlo de otra forma mientras el resultado sea el mismo.
| Cláusula | Qué hace | Puede ver |
|---|---|---|
1FROM / JOIN | Arma las filas: cada tabla, cada join. | Solo las columnas de las tablas |
2WHERE | Conserva las filas cuya prueba da TRUE. | Columnas; ni agregaciones ni alias del SELECT |
3GROUP BY | Reduce las filas a una sola fila por grupo. | Columnas |
4HAVING | Conserva los grupos cuya prueba da TRUE. | Agregaciones (SUM, COUNT…) |
5SELECT | Calcula las columnas de salida y define los alias; aquí se ejecutan las funciones de ventana. | Todo lo anterior |
6DISTINCT | Descarta las filas de salida duplicadas. | Las filas de salida |
7ORDER BY | Ordena las filas ya terminadas. | Alias y resultados de ventana |
8LIMIT / OFFSET | Recorta las filas ordenadas a una página. | Las filas ordenadas |
Por qué WHERE no puede ver un alias
WHERE se ejecuta en el paso 2 y el alias se define en el paso 5, así que todavía no existe. Repite la expresión, o calcúlala en una subconsulta o CTE y filtra afuera. ORDER BY se ejecuta después de SELECT, por eso puede usar el alias.
SQLite es permisivo y lo resuelve de todos modos: esto funciona ahí, y PostgreSQL lo rechaza:
SELECT name, salary * 2 AS doubled
FROM emp
WHERE doubled > 250| name | doubled |
|---|---|
| Cleo | 260 |
LeccionesOrden de ejecución de una consultaFundamentos de SELECTORDER BY y LIMITArtículoView vs Materialized View: Always Fresh or Stored and StaleArtículoUNION vs UNION ALL: Duplicates, Speed and Column RulesArtículoSQL ORDER BY and LIMIT: Top-N, OFFSET and Keyset Pagination
Joins
Un join empareja cada fila de la izquierda con cada fila de la derecha que cumple la condición ON. El tipo de join solo decide qué pasa con una fila sin pareja. La cantidad de filas de abajo corresponde a estas dos tablas:
| id | name |
|---|---|
| 1 | Pepper |
| 2 | Rusty |
| 3 | Nell |
| dog_id | adopter |
|---|---|
| 1 | Yusuf |
| 1 | Omar |
| 3 | Marta |
| 4 | Ines |
INNER JOIN
3 filas
Solo los pares que coinciden. Pepper coincide dos veces, así que aparece dos veces; Rusty e Ines desaparecen.
SELECT d.name, a.adopter FROM dog d JOIN adoption a ON a.dog_id = d.id3 filasResultado name adopter Pepper Omar Pepper Yusuf Nell Marta LEFT JOIN
4 filas
Todos los perros. Un perro sin pareja aparece una vez, con NULL a la derecha.
SELECT d.name, a.adopter FROM dog d LEFT JOIN adoption a ON a.dog_id = d.id4 filasResultado name adopter Pepper Omar Pepper Yusuf Rusty NULL Nell Marta RIGHT JOIN
4 filas
Todas las adopciones: un LEFT JOIN leído desde el otro lado. El perro 4 de Ines no está en la tabla dog.
SELECT d.name, a.adopter FROM dog d RIGHT JOIN adoption a ON a.dog_id = d.id4 filasResultado name adopter Pepper Yusuf Pepper Omar Nell Marta NULL Ines SQLite tiene la palabra clave desde la 3.39; estas filas salieron de la forma equivalente con LEFT JOIN en la 3.37, y coinciden con la palabra clave en versiones más nuevas.
FULL OUTER JOIN
5 filas
Todas las filas de ambos lados, emparejadas donde se puede. MySQL no tiene FULL JOIN: escribe un LEFT JOIN y, con UNION ALL, las filas de la derecha sin pareja.
SELECT d.name, a.adopter FROM dog d FULL JOIN adoption a ON a.dog_id = d.id5 filasResultado name adopter Pepper Omar Pepper Yusuf Rusty NULL Nell Marta NULL Ines SQLite tiene la palabra clave desde la 3.39; estas filas salieron de la forma equivalente con LEFT JOIN en la 3.37, y coinciden con la palabra clave en versiones más nuevas.
CROSS JOIN
12 filas
Cada perro emparejado con cada adopción, sin condición: 3 × 4 filas.
SELECT COUNT(*) AS n FROM dog CROSS JOIN adoptionSemi-join (EXISTS)
2 filas
Los perros que tienen al menos una coincidencia, cada uno una sola vez, sin importar cuántas tenga.
SELECT d.name FROM dog d WHERE EXISTS ( SELECT 1 FROM adoption a WHERE a.dog_id = d.id)2 filasResultado name Pepper Nell Anti-join
1 fila
Los perros sin pareja: un LEFT JOIN y después conservar las filas cuya clave de la derecha volvió como NULL.
SELECT d.name FROM dog d LEFT JOIN adoption a ON a.dog_id = d.id WHERE a.dog_id IS NULL1 filaResultado name Rusty LEFT JOIN + WHERE sobre la tabla derecha
2 filas
El adopter NULL de Rusty no pasa la prueba, así que el LEFT JOIN se convirtió sin avisar en un INNER JOIN. Mueve la condición al ON (AND a.adopter <> 'Omar') y Rusty vuelve: 3 filas.
SELECT d.name, a.adopter FROM dog d LEFT JOIN adoption a ON a.dog_id = d.id WHERE a.adopter <> 'Omar'2 filasResultado name adopter Pepper Yusuf Nell Marta
LecciónINNER JOIN y OUTER JOINArtículoDP-700 vs DP-600: Which Microsoft Fabric Exam Should You Take
Agregación y HAVING
GROUP BY produce una fila por cada valor distinto; las agregaciones se calculan por grupo. WHERE filtra filas antes de agrupar, HAVING filtra grupos después.
- Condiciones de fila en WHERE, condiciones de grupo en
HAVING. Una condición de fila enHAVINGfunciona, pero agrupa filas que podría haber descartado. - COUNT(*) cuenta filas;
COUNT(col)omite los NULL;COUNT(DISTINCT col)cuenta valores. - El SUM de cero filas es NULL, no 0: usa
COALESCE(SUM(x), 0)cuando un reporte necesita un número. - Cada columna seleccionada está agrupada o agregada. SQLite acepta una columna suelta y elige una fila; PostgreSQL rechaza la consulta.
SELECT dept, COUNT(*) AS n,
AVG(salary) AS avg_salary
FROM emp
WHERE salary >= 90
GROUP BY dept
HAVING COUNT(*) >= 3| dept | n | avg_salary |
|---|---|---|
| eng | 4 | 110 |
SELECT COUNT(*) AS all_rows,
COUNT(manager_id) AS has_manager,
COUNT(DISTINCT salary) AS salaries
FROM emp| all_rows | has_manager | salaries |
|---|---|---|
| 7 | 6 | 5 |
SELECT SUM(amount) AS total,
COALESCE(SUM(amount), 0) AS safe
FROM orders
WHERE customer_id = 2| total | safe |
|---|---|
| NULL | 0 |
LecciónAgregaciones y GROUP BYArtículoPL-300 vs DP-600: Power BI Data Analyst or Fabric Analytics Engineer
Funciones de ventana
f() OVER (PARTITION BY … ORDER BY …) calcula sobre filas relacionadas y conserva cada fila. PARTITION BY la reinicia por grupo; ORDER BY define “hasta ahora”. Las ventanas se ejecutan con SELECT, después de WHERE: para filtrar por una, envuelve la consulta.
| Función | Devuelve | En los ejemplos de abajo |
|---|---|---|
ROW_NUMBER() | 1, 2, 3…: nunca se repite. Los empates se ordenan de forma arbitraria, salvo que el ORDER BY los desempate. | Ben, Dev, Gus (todos con 95) → 4, 5, 6 |
RANK() | Los empates comparten número y después salta. | 95, 95, 95 → 4, 4, 4; Eve, la siguiente → 7 |
DENSE_RANK() | Los empates comparten número, sin huecos: la que se usa para “el N-ésimo valor más alto”. | 95, 95, 95 → 4, 4, 4; Eve, la siguiente → 5 |
LAG(x [, k]) | x de k filas atrás (por defecto 1); NULL antes de la primera fila. | prev en 09-02 → 40; en 09-01 → NULL |
LEAD(x [, k]) | x de k filas adelante; NULL después de la última fila. | next en 09-01 → 55; en 09-04 → NULL |
SUM(x) OVER (…) | Con ORDER BY: un total acumulado. Solo con PARTITION BY: el total del grupo en cada fila. | so_far → 40, 95, 130, 185; dept_total de eng → 440 en cada fila de eng |
Un ranking resuelto: tres 95
ROW_NUMBER desempata por nombre, RANK salta a 7 después del empate y DENSE_RANK no salta.
SELECT name, salary,
ROW_NUMBER() OVER (
ORDER BY salary DESC, name) AS rn,
RANK() OVER w AS rnk,
DENSE_RANK() OVER w AS drnk
FROM emp
WINDOW w AS (ORDER BY salary DESC)
ORDER BY rn| name | salary | rn | rnk | drnk |
|---|---|---|---|---|
| Cleo | 130 | 1 | 1 | 1 |
| Ana | 120 | 2 | 2 | 2 |
| Finn | 100 | 3 | 3 | 3 |
| Ben | 95 | 4 | 4 | 4 |
| Dev | 95 | 5 | 4 | 4 |
| Gus | 95 | 6 | 4 | 4 |
| Eve | 80 | 7 | 7 | 5 |
Vecinos y un total acumulado
WINDOW w AS (…) le da nombre a una ventana que comparten varias funciones.
SELECT day, amount,
LAG(amount) OVER w AS prev,
LEAD(amount) OVER w AS next,
SUM(amount) OVER w AS so_far
FROM sale
WINDOW w AS (ORDER BY day)
ORDER BY day| day | amount | prev | next | so_far |
|---|---|---|---|---|
| 2026-09-01 | 40 | NULL | 55 | 40 |
| 2026-09-02 | 55 | 40 | 35 | 95 |
| 2026-09-03 | 35 | 55 | 55 | 130 |
| 2026-09-04 | 55 | 35 | NULL | 185 |
El total del grupo en cada fila
PARTITION BY sin ORDER BY: la respuesta de GROUP BY, conservando las filas.
SELECT name, dept, salary,
SUM(salary) OVER (
PARTITION BY dept) AS dept_total
FROM emp
ORDER BY dept, name| name | dept | salary | dept_total |
|---|---|---|---|
| Ana | eng | 120 | 440 |
| Ben | eng | 95 | 440 |
| Cleo | eng | 130 | 440 |
| Gus | eng | 95 | 440 |
| Dev | ops | 95 | 275 |
| Eve | ops | 80 | 275 |
| Finn | ops | 100 | 275 |
El marco por defecto y los empates
Con ORDER BY y sin marco, el marco es RANGE … CURRENT ROW: las filas empatadas en la clave se suman juntas, así que los dos 55 muestran 185. Escribe ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW y verás 130 y después 185.
SELECT amount,
SUM(amount) OVER (
ORDER BY amount) AS t
FROM sale
ORDER BY amount| amount | t |
|---|---|
| 35 | 35 |
| 40 | 75 |
| 55 | 185 |
| 55 | 185 |
LecciónFunciones de ventanaArtículoRANK vs DENSE_RANK vs ROW_NUMBER: How Each Handles Ties
Subconsultas vs. CTE
Una CTE es una subconsulta con nombre: el mismo poder, se lee de arriba abajo y se puede usar dos veces en una sentencia. Solo una CTE recursiva puede hacer algo que una subconsulta no. Si una CTE se calcula una vez o se integra en la consulta lo decide el motor (PostgreSQL 12+ integra una CTE usada una sola vez salvo que escribas MATERIALIZED).
| Forma | Se ve así | Se ejecuta | Úsala cuando |
|---|---|---|---|
| Subconsulta escalar | WHERE salary > (SELECT AVG(salary) FROM emp) | Una vez. Debe devolver una fila y una columna. | Comparar con un único valor calculado. |
| IN / NOT IN | WHERE id IN (SELECT customer_id FROM orders) | Una vez, como lista. | Pertenencia. Nunca NOT IN sobre una columna que puede contener NULL. |
| EXISTS / NOT EXISTS | WHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id) | Por cada fila externa; se detiene en la primera coincidencia. | Semi-joins y anti-joins; seguro frente a NULL. |
| Subconsulta correlacionada | WHERE salary > (SELECT AVG(salary) FROM emp WHERE dept = e.dept) | Por cada fila externa (salvo que el planificador la reescriba). | Es corta de escribir; vigila el costo en tablas grandes. |
| Tabla derivada | FROM (SELECT dept, AVG(salary) … GROUP BY dept) AS d | Una vez, como tabla en el FROM. | Filtrar por una agregación o por un resultado de ventana. |
| CTE (WITH) | WITH dept_avg AS (SELECT …) SELECT … FROM dept_avg | Como una tabla derivada con nombre. | Varios pasos que se leen de arriba abajo; un resultado que se usa dos veces. |
| CTE recursiva | WITH RECURSIVE chain AS (anchor UNION ALL step) | El ancla una vez y luego el paso, hasta que no devuelve nada. | Árboles y grafos: organigramas, listas de materiales, caminos. |
La misma pregunta, tres formas: ¿quién gana más que el promedio de su departamento?
Subconsulta correlacionada
SELECT e.name
FROM emp e
WHERE e.salary > (
SELECT AVG(salary) FROM emp
WHERE dept = e.dept)
ORDER BY e.name| name |
|---|
| Ana |
| Cleo |
| Dev |
| Finn |
Tabla derivada
SELECT e.name
FROM emp e
JOIN (SELECT dept, AVG(salary) AS avg_s
FROM emp GROUP BY dept) AS d
ON d.dept = e.dept
WHERE e.salary > d.avg_s
ORDER BY e.name| name |
|---|
| Ana |
| Cleo |
| Dev |
| Finn |
CTE
WITH dept_avg AS (
SELECT dept, AVG(salary) AS avg_s
FROM emp GROUP BY dept
)
SELECT e.name
FROM emp e
JOIN dept_avg d ON d.dept = e.dept
WHERE e.salary > d.avg_s
ORDER BY e.name| name |
|---|
| Ana |
| Cleo |
| Dev |
| Finn |
LeccionesSubconsultasCTE y recursiónArtículoEXISTS vs IN vs JOIN for "Is There a Match": Duplicates and NULLsArtículoCTE vs Subquery vs Temp Table: Readability, Reuse and Materialization
NULL
NULL significa desconocido, así que SQL tiene tres valores de verdad: TRUE, FALSE y UNKNOWN. WHERE, ON y HAVING conservan una fila solo cuando la prueba da TRUE: UNKNOWN se descarta igual que FALSE.
| Expresión | Resultado | Por qué |
|---|---|---|
NULL = NULL | NULL | De dos valores desconocidos no se sabe si son iguales. |
NULL <> 1 | NULL | Cualquier comparación con NULL es desconocida. |
NULL AND FALSE | FALSE | FALSE, sea cual sea el valor desconocido. |
NULL OR TRUE | TRUE | TRUE, sea cual sea el valor desconocido. |
NOT NULL | NULL | Negar lo desconocido sigue siendo desconocido. |
NULL IS NULL | TRUE | IS es la prueba que puede ver NULL. |
1 IN (1, NULL) | TRUE | Se encontró una coincidencia. |
2 IN (1, NULL) | NULL | 2 = NULL es desconocido, así que no hay un FALSE limpio. |
2 NOT IN (1, NULL) | NULL | …y por eso NOT IN nunca es TRUE: la trampa de abajo. |
La trampa de NOT IN
El pedido 4 tiene un customer_id NULL. Entonces cada prueba de NOT IN se encuentra con un NULL y da UNKNOWN, así que Jon, que nunca hizo un pedido, no aparece. NOT EXISTS es seguro frente a NULL.
SELECT name FROM customer
WHERE id NOT IN (
SELECT customer_id FROM orders)| name |
|---|
| (sin filas) |
SELECT c.name FROM customer c
WHERE NOT EXISTS (
SELECT 1 FROM orders o
WHERE o.customer_id = c.id)| name |
|---|
| Jon |
COALESCE
COALESCE(a, b, …) devuelve el primer argumento que no es NULL. Jon no tiene pedidos, así que su fila del LEFT JOIN suma NULL, y se muestra como 0.
SELECT c.name,
COALESCE(SUM(o.amount), 0) AS spent
FROM customer c
LEFT JOIN orders o ON o.customer_id = c.id
GROUP BY c.id, c.name
ORDER BY c.id| name | spent |
|---|---|
| Ivy | 70 |
| Jon | 0 |
| Kai | 25 |
- Las claves NULL nunca hacen join, ni siquiera con otro NULL.
- GROUP BY pone todos los NULL en un solo grupo, y
DISTINCTconserva uno de ellos. - Ordenamiento: SQLite y MySQL ponen NULL primero en orden ascendente (Ana, que no tiene jefe, va primera aquí); PostgreSQL lo pone al final. Escribe
NULLS FIRSToNULLS LASTcuando importa.
LecciónWHERE y filtradoArtículoCHAR vs VARCHAR vs TEXT: Padding, Length Limits and Speed
Índices
Un índice es una segunda copia ordenada de algunas columnas, normalmente un B-tree, con un puntero de vuelta a cada fila. Los planes de abajo son el EXPLAIN QUERY PLAN de SQLite sobre una tabla de fotos con un índice en (shot_by, year): SCAN lee cada fila, SEARCH salta directo.
| Caso | Consulta | Plan (SQLite) | Por qué |
|---|---|---|---|
| Sin índice: escaneo completo | SELECT box FROM photo
WHERE shot_by = 'Weiss' | SCAN photo | Se lee y se prueba cada fila: O(n), sea cual sea el tamaño de la respuesta. |
| Lo que ahorra un índice | SELECT box FROM photo
WHERE shot_by = 'Weiss' | SEARCH photo USING INDEX photo_by_year (shot_by=?) | Una búsqueda en el B-tree hasta la primera coincidencia y después las coincidencias: O(log n + k). |
| Compuesto: prefijo izquierdo | SELECT box FROM photo
WHERE shot_by = 'Weiss' AND year = 1998 | SEARCH photo USING INDEX photo_by_year (shot_by=? AND year=?) | Ordenado por shot_by y, dentro de cada uno, por year: igualdad en la primera columna y después en la segunda. |
| Se ignora: solo la segunda columna | SELECT box FROM photo
WHERE year = 1998 | SCAN photo | year solo está ordenado dentro de cada shot_by, así que no hay un punto al que saltar. |
| Índice de cobertura | SELECT year FROM photo
WHERE shot_by = 'Weiss' | SEARCH photo USING COVERING INDEX photo_by_year (shot_by=?) | Todas las columnas que necesita la consulta están en el índice, así que la tabla nunca se lee. |
| Se ignora: una función sobre la columna | SELECT box FROM photo
WHERE lower(shot_by) = 'weiss' | SCAN photo | El índice está ordenado por shot_by, no por lower(shot_by). Reescribe la condición o indexa la expresión. |
| Se ignora: comodín al inicio | SELECT box FROM photo
WHERE shot_by LIKE '%eiss' | SCAN photo | Un patrón que puede empezar con cualquier cosa no tiene un punto de partida ordenado. |
| ORDER BY resuelto por el índice | SELECT shot_by, year FROM photo
ORDER BY shot_by, year | SCAN photo USING COVERING INDEX photo_by_year | Las filas ya salen ordenadas. ORDER BY box, en cambio, agrega USE TEMP B-TREE FOR ORDER BY. |
- Costo: un escaneo es O(n); una búsqueda por índice es O(log n) más las k coincidencias, más una búsqueda de fila por cada una salvo que el índice cubra la consulta.
- Cada escritura paga: cada insert, delete y update de una columna indexada también actualiza cada índice que la contiene: O(log n) más por índice, y más almacenamiento.
- El planificador puede ignorar un buen índice cuando la consulta coincide con una parte grande de la tabla: un solo escaneo secuencial puede ganarle a muchas búsquedas de fila.
- El orden en un índice compuesto importa: pon primero la columna por la que siempre filtras con
=; el índice sirve para cualquier prefijo izquierdo de sus columnas.
LeccionesÍndicesÍndices compuestosCómo leer un plan de consultaArtículoIndex vs Primary Key: The Rule and the Structure That Enforces ItArtículoComposite and Covering Indexes: Why Column Order MattersArtículoHow to Read a Query Plan: EXPLAIN in SQL, Line by Line
El problema N+1
Una consulta para una lista y después una más por cada fila. Cada una es rápida; el costo son los viajes de ida y vuelta, y su cantidad crece con los datos: por eso pasa con diez filas y se arrastra con quinientas. Los ORM lo hacen por defecto cuando una relación se carga de forma diferida (lazy).
| Enfoque | Sentencias | Contadas para 3 trabajos |
|---|---|---|
| Una consulta para la lista y una por fila | 1 + N | 4 |
| Un JOIN | 1 | 1 |
| La lista y después un WHERE job_id IN (…) | 2 | 2 |
Contadas con el callback de trace de SQLite, que registra cada sentencia que ejecuta. Pasa los ids de la lista IN (…) como parámetros, nunca los pegues en el texto; indexa la clave foránea, o cada una de las N consultas será además un escaneo, no solo un viaje.
LecciónEl problema de consultas N+1ArtículoThe N+1 Query Problem: How to Spot It and Fix It
Transacciones y aislamiento
Una transacción es una unidad de trabajo. El nivel de aislamiento es cuánto puede ver de otras transacciones sin terminar: cada escalón descarta una anomalía más y cuesta algo de concurrencia.
- AAtómica
- Se aplican todas las sentencias o ninguna; un fallo también revierte las anteriores.
- CConsistente
- Las restricciones (CHECK, claves foráneas, UNIQUE) se cumplen antes y después.
- IAislada
- Los demás no ven tu trabajo a medio terminar; qué tan estricto es lo decide el nivel de aislamiento.
- DDurable
- Después del commit, sobrevive a una caída.
| Nivel | Lectura sucia | Lectura no repetible | Fantasma | En una línea |
|---|---|---|---|---|
| Read uncommitted | Posible | Posible | Posible | Puedes leer escrituras de otra transacción que todavía no están confirmadas. |
| Read committed | Evitada | Posible | Posible | Cada sentencia ve lo que estaba confirmado antes de que empezara. |
| Repeatable read | Evitada | Evitada | Posible | Una fila que leíste se sigue leyendo igual hasta que terminas. |
| Serializable | Evitada | Evitada | Evitada | El resultado equivale a algún orden de una transacción a la vez. Reintenta ante fallos de serialización. |
Sucia: lees datos sin commit. No repetible: una fila que leíste dos veces cambió. Fantasma: cambió el conjunto de filas que cumplen una condición. Los motores pueden dar más que el mínimo (el repeatable read de PostgreSQL también evita los fantasmas) y los valores por defecto difieren: read committed en PostgreSQL, repeatable read en InnoDB de MySQL, y SQLite ejecuta toda transacción como serializable.
LeccionesTransacciones y ACIDNiveles de aislamientoArtículoOptimistic vs Pessimistic Locking: SELECT FOR UPDATE vs Version ColumnArtículoSQL Isolation Levels Explained with Examples
Consultas de entrevista
Las preguntas que salen una y otra vez, cada una sobre las tablas de ejemplo con las filas que devolvió.
Segundo salario más alto
El segundo salario distinto más alto, o NULL si no existe.
SELECT MAX(salary) AS second FROM emp WHERE salary < (SELECT MAX(salary) FROM emp)1 filaResultado second 120 Una agregación sobre cero filas da una fila con NULL, así que una tabla con un solo salario responde NULL, no cero filas.
- Lección
- Subconsultas · SQL
- Práctica
N-ésimo salario más alto
El tercer salario distinto más alto.
SELECT DISTINCT salary FROM ( SELECT salary, DENSE_RANK() OVER ( ORDER BY salary DESC) AS r FROM emp) AS ranked WHERE r = 31 filaResultado salary 100 DENSE_RANK, no RANK: los tres 95 empujarían a RANK más allá de 5 y dejarían huecos.
- Lección
- Funciones de ventana · SQL
- Práctica
Encontrar duplicados
Los correos que se registraron más de una vez, y cuántas veces.
SELECT email, COUNT(*) AS n FROM signup GROUP BY email HAVING COUNT(*) > 1 ORDER BY email2 filasResultado email n a@x.io 3 b@x.io 2 Para conservar el primero de cada uno: DELETE FROM signup WHERE id NOT IN (SELECT MIN(id) FROM signup GROUP BY email) deja los ids 1, 2, 4.
- Lección
- Agregaciones y GROUP BY · SQL
- Práctica
Filas sin coincidencia
Los clientes que nunca hicieron un pedido.
SELECT c.name FROM customer c WHERE NOT EXISTS ( SELECT 1 FROM orders o WHERE o.customer_id = c.id)1 filaResultado name Jon NOT IN (SELECT customer_id FROM orders) no devuelve filas aquí: el pedido 4 tiene un customer_id NULL.
- Lección
- INNER JOIN y OUTER JOIN · SQL
- Práctica
Gana más que su jefe
Los empleados que ganan más que la persona a la que reportan.
SELECT e.name, e.salary, m.salary AS manager_salary FROM emp e JOIN emp m ON m.id = e.manager_id WHERE e.salary > m.salary ORDER BY e.name2 filasResultado name salary manager_salary Cleo 130 120 Finn 100 95 Un self-join: la misma tabla dos veces, con dos alias. El inner join descarta a Ana, que no tiene jefe.
- Lección
- INNER JOIN y OUTER JOIN · SQL
Top N por grupo
Las dos personas mejor pagadas de cada departamento.
SELECT dept, name, salary FROM ( SELECT *, ROW_NUMBER() OVER ( PARTITION BY dept ORDER BY salary DESC) AS rn FROM emp) AS ranked WHERE rn <= 2 ORDER BY dept, rn4 filasResultado dept name salary eng Cleo 130 eng Ana 120 ops Finn 100 ops Dev 95 Una ventana no puede ir en el WHERE, así que calcula el ranking en una subconsulta y filtra afuera. ROW_NUMBER da exactamente N; DENSE_RANK conserva los empates (el top 3 de eng son entonces 4 personas).
- Lección
- Funciones de ventana · SQL
- Práctica
Total acumulado
Las ventas acumuladas, día a día.
SELECT day, amount, SUM(amount) OVER ( ORDER BY day) AS total FROM sale ORDER BY day4 filasResultado day amount total 2026-09-01 40 40 2026-09-02 55 95 2026-09-03 35 130 2026-09-04 55 185 El marco por defecto es RANGE: las filas empatadas en la clave del ORDER BY comparten un total. Escribe ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW para una suma estricta fila a fila.
- Lección
- Funciones de ventana · SQL
- Práctica
Tres días seguidos
Las personas que iniciaron sesión al menos tres días consecutivos.
SELECT DISTINCT person FROM ( SELECT person, day, LAG(day, 2) OVER ( PARTITION BY person ORDER BY day) AS two_back FROM login) AS t WHERE julianday(day) - julianday(two_back) = 21 filaResultado person kim Dos filas atrás equivale a dos días atrás solo si cada fila es un día distinto: elimina primero los inicios de sesión duplicados.
Dialectojulianday() es de SQLite. Con columnas DATE de PostgreSQL, day - two_back = 2; en MySQL, DATEDIFF(day, two_back) = 2.
- Lección
- Funciones de ventana · SQL
- Práctica
Huecos e islas
Agrupar en tramos los números de asiento ocupados.
SELECT MIN(n) AS run_start, MAX(n) AS run_end FROM ( SELECT n, n - ROW_NUMBER() OVER ( ORDER BY n) AS grp FROM seat) AS t GROUP BY grp ORDER BY run_start3 filasResultado run_start run_end 1 3 5 6 9 9 Dentro de un tramo, el valor y el número de fila suben juntos, así que su diferencia es constante: esa diferencia es el grupo. Los huecos están entre un run_end y el siguiente run_start.
- Lección
- Funciones de ventana · SQL
- Práctica
Todos los que dependen de un jefe
El organigrama completo desde arriba, con la profundidad de cada persona.
WITH RECURSIVE chain AS ( SELECT id, name, 0 AS depth FROM emp WHERE manager_id IS NULL UNION ALL SELECT e.id, e.name, c.depth + 1 FROM emp e JOIN chain c ON e.manager_id = c.id ) SELECT name, depth FROM chain ORDER BY depth, name7 filasResultado name depth Ana 0 Ben 1 Cleo 1 Dev 1 Eve 2 Finn 2 Gus 2 El ancla y después un paso que vuelve a hacer join con la CTE hasta que no encuentra nada. Si los datos tienen un ciclo, nunca termina: limita la profundidad o lleva la cuenta de los ids visitados.
- Lección
- CTE y recursión · SQL
- Práctica
- Usuarios retenidos mes a mesDifícil
Errores comunes
- Un alias del SELECT o una agregación en el WHEREHAVING para las agregaciones; para los alias, repite la expresión o filtra en una consulta externa
- col = NULLcol IS NULL: una comparación con NULL nunca es TRUE
- NOT IN sobre una columna que puede contener NULLNOT EXISTS, o quita los NULL de la subconsulta
- Un WHERE sobre la tabla derecha después de un LEFT JOINPon la condición en el ON, o las filas sin pareja desaparecen
- SUM o COUNT sobre un join que multiplica filasHaz primero la agregación del lado de muchos y después el join
- COUNT(col) cuando querías contar filasCOUNT(*) cuenta filas; COUNT(col) omite los NULL
- LIMIT sin ORDER BYSin ORDER BY no hay orden: las filas que quedan son las que llegaron primero
- RANK para “exactamente N por grupo”ROW_NUMBER para exactamente N; RANK y DENSE_RANK conservan los empates
- Una función sobre una columna indexadaCompara la columna tal cual, o indexa la expresión
- Una consulta dentro de un bucleUn JOIN, o un WHERE id IN (…) para toda la lista
- Leer, calcular en la app y volver a escribirHaz la cuenta en un solo UPDATE, o de dos escrituras simultáneas se pierde una
bytepatterns.com/cheatsheets/sql: cada fila enlaza ahí a una lección animada.