Saltar al contenido

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í.

emp
idnamedeptsalarymanager_id
1Anaeng120NULL
2Beneng951
3Cleoeng1301
4Devops951
5Eveops804
6Finnops1004
7Guseng953
customer
idname
1Ivy
2Jon
3Kai
orders
idcustomer_idamount
1130
2140
3325
4NULL10
signup
idemail
1a@x.io
2b@x.io
3a@x.io
4c@x.io
5b@x.io
6a@x.io
sale
dayamount
2026-09-0140
2026-09-0255
2026-09-0335
2026-09-0455
login
personday
kim2026-09-01
kim2026-09-02
kim2026-09-03
kim2026-09-05
lou2026-09-01
lou2026-09-03
lou2026-09-04
seat
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.

El orden lógico en que se evalúa un SELECT
CláusulaQué hacePuede ver
1FROM / JOINArma las filas: cada tabla, cada join.Solo las columnas de las tablas
2WHEREConserva las filas cuya prueba da TRUE.Columnas; ni agregaciones ni alias del SELECT
3GROUP BYReduce las filas a una sola fila por grupo.Columnas
4HAVINGConserva los grupos cuya prueba da TRUE.Agregaciones (SUM, COUNT…)
5SELECTCalcula las columnas de salida y define los alias; aquí se ejecutan las funciones de ventana.Todo lo anterior
6DISTINCTDescarta las filas de salida duplicadas.Las filas de salida
7ORDER BYOrdena las filas ya terminadas.Alias y resultados de ventana
8LIMIT / OFFSETRecorta 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
1 fila
Resultado
namedoubled
Cleo260

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:

dog
idname
1Pepper
2Rusty
3Nell
adoption
dog_idadopter
1Yusuf
1Omar
3Marta
4Ines
  • 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.id
    3 filas
    Resultado
    nameadopter
    PepperOmar
    PepperYusuf
    NellMarta
  • 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.id
    4 filas
    Resultado
    nameadopter
    PepperOmar
    PepperYusuf
    RustyNULL
    NellMarta
  • 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.id
    4 filas
    Resultado
    nameadopter
    PepperYusuf
    PepperOmar
    NellMarta
    NULLInes

    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.id
    5 filas
    Resultado
    nameadopter
    PepperOmar
    PepperYusuf
    RustyNULL
    NellMarta
    NULLInes

    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 adoption
  • Semi-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 filas
    Resultado
    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 NULL
    1 fila
    Resultado
    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 filas
    Resultado
    nameadopter
    PepperYusuf
    NellMarta

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 en HAVING funciona, 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
1 fila
Resultado
deptnavg_salary
eng4110
SELECT COUNT(*) AS all_rows,
  COUNT(manager_id) AS has_manager,
  COUNT(DISTINCT salary) AS salaries
FROM emp
1 fila
Resultado
all_rowshas_managersalaries
765
SELECT SUM(amount) AS total,
  COALESCE(SUM(amount), 0) AS safe
FROM orders
WHERE customer_id = 2
1 fila
Resultado
totalsafe
NULL0

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.

Funciones de ventana: qué devuelve cada una
FunciónDevuelveEn 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
7 filas
Resultado
namesalaryrnrnkdrnk
Cleo130111
Ana120222
Finn100333
Ben95444
Dev95544
Gus95644
Eve80775

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
4 filas
Resultado
dayamountprevnextso_far
2026-09-0140NULL5540
2026-09-0255403595
2026-09-03355555130
2026-09-045535NULL185

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
7 filas
Resultado
namedeptsalarydept_total
Anaeng120440
Beneng95440
Cleoeng130440
Guseng95440
Devops95275
Eveops80275
Finnops100275

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
4 filas
Resultado
amountt
3535
4075
55185
55185

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).

Formas de subconsulta y expresiones de tabla comunes (CTE)
FormaSe ve asíSe ejecutaÚsala cuando
Subconsulta escalarWHERE salary > (SELECT AVG(salary) FROM emp)Una vez. Debe devolver una fila y una columna.Comparar con un único valor calculado.
IN / NOT INWHERE id IN (SELECT customer_id FROM orders)Una vez, como lista.Pertenencia. Nunca NOT IN sobre una columna que puede contener NULL.
EXISTS / NOT EXISTSWHERE 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 correlacionadaWHERE 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 derivadaFROM (SELECT dept, AVG(salary) … GROUP BY dept) AS dUna 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_avgComo una tabla derivada con nombre.Varios pasos que se leen de arriba abajo; un resultado que se usa dos veces.
CTE recursivaWITH 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
4 filas
Resultado
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
4 filas
Resultado
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
4 filas
Resultado
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.

Lógica de tres valores (SQLite imprime TRUE como 1 y FALSE como 0)
ExpresiónResultadoPor qué
NULL = NULLNULLDe dos valores desconocidos no se sabe si son iguales.
NULL <> 1NULLCualquier comparación con NULL es desconocida.
NULL AND FALSEFALSEFALSE, sea cual sea el valor desconocido.
NULL OR TRUETRUETRUE, sea cual sea el valor desconocido.
NOT NULLNULLNegar lo desconocido sigue siendo desconocido.
NULL IS NULLTRUEIS es la prueba que puede ver NULL.
1 IN (1, NULL)TRUESe encontró una coincidencia.
2 IN (1, NULL)NULL2 = 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)
0 filas
Resultado
name
(sin filas)
SELECT c.name FROM customer c
WHERE NOT EXISTS (
  SELECT 1 FROM orders o
  WHERE o.customer_id = c.id)
1 fila
Resultado
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
3 filas
Resultado
namespent
Ivy70
Jon0
Kai25
  • Las claves NULL nunca hacen join, ni siquiera con otro NULL.
  • GROUP BY pone todos los NULL en un solo grupo, y DISTINCT conserva 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 FIRST o NULLS LAST cuando 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.

En qué ayuda un índice y en qué no
CasoConsultaPlan (SQLite)Por qué
Sin índice: escaneo completoSELECT box FROM photo WHERE shot_by = 'Weiss'SCAN photoSe lee y se prueba cada fila: O(n), sea cual sea el tamaño de la respuesta.
Lo que ahorra un índiceSELECT 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 izquierdoSELECT box FROM photo WHERE shot_by = 'Weiss' AND year = 1998SEARCH 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 columnaSELECT box FROM photo WHERE year = 1998SCAN photoyear solo está ordenado dentro de cada shot_by, así que no hay un punto al que saltar.
Índice de coberturaSELECT 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 columnaSELECT box FROM photo WHERE lower(shot_by) = 'weiss'SCAN photoEl í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 inicioSELECT box FROM photo WHERE shot_by LIKE '%eiss'SCAN photoUn patrón que puede empezar con cualquier cosa no tiene un punto de partida ordenado.
ORDER BY resuelto por el índiceSELECT shot_by, year FROM photo ORDER BY shot_by, yearSCAN photo USING COVERING INDEX photo_by_yearLas 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).

Sentencias enviadas para N trabajos y sus piezas
EnfoqueSentenciasContadas para 3 trabajos
Una consulta para la lista y una por fila1 + N4
Un JOIN11
La lista y después un WHERE job_id IN (…)22

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.
Lo que permite cada nivel (los mínimos del estándar SQL)
NivelLectura suciaLectura no repetibleFantasmaEn una línea
Read uncommittedPosiblePosiblePosiblePuedes leer escrituras de otra transacción que todavía no están confirmadas.
Read committedEvitadaPosiblePosibleCada sentencia ve lo que estaba confirmado antes de que empezara.
Repeatable readEvitadaEvitadaPosibleUna fila que leíste se sigue leyendo igual hasta que terminas.
SerializableEvitadaEvitadaEvitadaEl 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 fila
    Resultado
    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
  • 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 = 3
    1 fila
    Resultado
    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
  • 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 email
    2 filas
    Resultado
    emailn
    a@x.io3
    b@x.io2

    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.

  • 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 fila
    Resultado
    name
    Jon

    NOT IN (SELECT customer_id FROM orders) no devuelve filas aquí: el pedido 4 tiene un customer_id NULL.

  • 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.name
    2 filas
    Resultado
    namesalarymanager_salary
    Cleo130120
    Finn10095

    Un self-join: la misma tabla dos veces, con dos alias. El inner join descarta a Ana, que no tiene jefe.

  • 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, rn
    4 filas
    Resultado
    deptnamesalary
    engCleo130
    engAna120
    opsFinn100
    opsDev95

    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
  • 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 day
    4 filas
    Resultado
    dayamounttotal
    2026-09-014040
    2026-09-025595
    2026-09-0335130
    2026-09-0455185

    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
  • 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) = 2
    1 fila
    Resultado
    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
  • 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_start
    3 filas
    Resultado
    run_startrun_end
    13
    56
    99

    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
  • 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, name
    7 filas
    Resultado
    namedepth
    Ana0
    Ben1
    Cleo1
    Dev1
    Eve2
    Finn2
    Gus2

    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

Errores comunes

bytepatterns.com/cheatsheets/sql: cada fila enlaza ahí a una lección animada.