Pular para o conteúdo

Cheat sheet de SQL para entrevistas

Ordem de execução, joins, funções de janela, NULL, índices e as consultas clássicas de entrevista, cada uma com as linhas que o SQLite retornou.

Atualizado em 10 consultas de entrevista55 resultados, cada um executado no SQLitePronta para imprimir — use a impressão do seu navegador

Cada resultado desta página é o que o SQLite retornou quando a consulta (query) acima dele foi executada nas pequenas tabelas de exemplo abaixo. A sintaxe é SQL padrão, salvo indicação na própria linha; onde PostgreSQL ou MySQL se comportam de forma diferente, a linha os cita.

Tabelas de exemplo

Uma pequena empresa. Os joins usam duas tabelas próprias, mostradas lá.

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

Ordem de execução

Escrito primeiro, SELECT é avaliado em quinto lugar. A ordem lógica decide o que cada cláusula consegue ver; o planejador pode executar de outro jeito, desde que o resultado seja o mesmo.

A ordem lógica em que um SELECT é avaliado
CláusulaO que fazO que enxerga
1FROM / JOINMonta as linhas: todas as tabelas, todos os joins.Só as colunas das tabelas
2WHEREMantém as linhas cujo teste dá TRUE.Colunas — sem agregações, sem aliases do SELECT
3GROUP BYCondensa as linhas em uma linha por grupo.Colunas
4HAVINGMantém os grupos cujo teste dá TRUE.Agregações (SUM, COUNT…)
5SELECTCalcula as colunas de saída e nomeia os aliases; as funções de janela rodam aqui.Tudo o que vem acima
6DISTINCTDescarta linhas de saída duplicadas.As linhas de saída
7ORDER BYOrdena as linhas prontas.Aliases e resultados de janela
8LIMIT / OFFSETCorta as linhas ordenadas em uma página.As linhas ordenadas

Por que o WHERE não enxerga um alias

WHERE roda no passo 2 e o alias é nomeado no passo 5, então ele ainda não existe. Repita a expressão, ou calcule-a em uma subconsulta (subquery) ou CTE e filtre por fora. ORDER BY roda depois de SELECT, por isso pode usar o alias.

O SQLite é permissivo e resolve mesmo assim — isto roda nele, e o PostgreSQL rejeita:

SELECT name, salary * 2 AS doubled
FROM emp
WHERE doubled > 250
1 linha
Resultado
namedoubled
Cleo260

AulasOrdem de execução da consultaO básico de SELECTORDER BY e LIMITArtigoView vs Materialized View: Always Fresh or Stored and StaleArtigoUNION vs UNION ALL: Duplicates, Speed and Column RulesArtigoSQL ORDER BY and LIMIT: Top-N, OFFSET and Keyset Pagination

Joins

Um join emparelha cada linha da esquerda com cada linha da direita que atende à condição ON. O tipo de join só decide o que acontece com uma linha sem par. As contagens de linhas abaixo são para estas duas tabelas:

dog
idname
1Pepper
2Rusty
3Nell
adoption
dog_idadopter
1Yusuf
1Omar
3Marta
4Ines
  • INNER JOIN

    3 linhas

    Só os pares que combinam. Pepper combina duas vezes, então aparece duas vezes; Rusty e Ines somem.

    SELECT d.name, a.adopter
    FROM dog d
    JOIN adoption a ON a.dog_id = d.id
    3 linhas
    Resultado
    nameadopter
    PepperOmar
    PepperYusuf
    NellMarta
  • LEFT JOIN

    4 linhas

    Todo cachorro. Um cachorro sem par volta uma vez, com NULL à direita.

    SELECT d.name, a.adopter
    FROM dog d
    LEFT JOIN adoption a ON a.dog_id = d.id
    4 linhas
    Resultado
    nameadopter
    PepperOmar
    PepperYusuf
    RustyNULL
    NellMarta
  • RIGHT JOIN

    4 linhas

    Toda adoção — um LEFT JOIN lido do outro lado. O cachorro 4 da Ines não está na tabela dog.

    SELECT d.name, a.adopter
    FROM dog d
    RIGHT JOIN adoption a ON a.dog_id = d.id
    4 linhas
    Resultado
    nameadopter
    PepperYusuf
    PepperOmar
    NellMarta
    NULLInes

    O SQLite tem a palavra-chave a partir da 3.39; estas linhas vieram da forma equivalente com LEFT JOIN na 3.37 e coincidem com a palavra-chave nas versões mais novas.

  • FULL OUTER JOIN

    5 linhas

    Toda linha dos dois lados, emparelhada quando possível. O MySQL não tem FULL JOIN: escreva um LEFT JOIN e faça UNION ALL com as linhas da direita sem par.

    SELECT d.name, a.adopter
    FROM dog d
    FULL JOIN adoption a ON a.dog_id = d.id
    5 linhas
    Resultado
    nameadopter
    PepperOmar
    PepperYusuf
    RustyNULL
    NellMarta
    NULLInes

    O SQLite tem a palavra-chave a partir da 3.39; estas linhas vieram da forma equivalente com LEFT JOIN na 3.37 e coincidem com a palavra-chave nas versões mais novas.

  • CROSS JOIN

    12 linhas

    Todo cachorro emparelhado com toda adoção, sem condição: 3 × 4 linhas.

    SELECT COUNT(*) AS n
    FROM dog CROSS JOIN adoption
  • Semi-join (EXISTS)

    2 linhas

    Cachorros que têm pelo menos um par — cada um uma vez, não importa quantos pares tenha.

    SELECT d.name FROM dog d
    WHERE EXISTS (
      SELECT 1 FROM adoption a
      WHERE a.dog_id = d.id)
    2 linhas
    Resultado
    name
    Pepper
    Nell
  • Anti-join

    1 linha

    Cachorros sem par: LEFT JOIN e depois mantenha as linhas cuja chave da direita voltou NULL.

    SELECT d.name
    FROM dog d
    LEFT JOIN adoption a ON a.dog_id = d.id
    WHERE a.dog_id IS NULL
    1 linha
    Resultado
    name
    Rusty
  • LEFT JOIN + WHERE na tabela da direita

    2 linhas

    O adopter NULL do Rusty falha no teste, então o LEFT JOIN virou um INNER sem avisar. Leve a condição para o ON (AND a.adopter <> 'Omar') e o Rusty volta: 3 linhas.

    SELECT d.name, a.adopter
    FROM dog d
    LEFT JOIN adoption a ON a.dog_id = d.id
    WHERE a.adopter <> 'Omar'
    2 linhas
    Resultado
    nameadopter
    PepperYusuf
    NellMarta

AulaJOINs INNER e OUTERArtigoDP-700 vs DP-600: Which Microsoft Fabric Exam Should You Take

Agregação e HAVING

GROUP BY gera uma linha por valor distinto; as agregações são calculadas por grupo. WHERE filtra linhas antes do agrupamento, HAVING filtra grupos depois dele.

  • Condições de linha no WHERE, condições de grupo no HAVING. Uma condição de linha no HAVING funciona, mas agrupa linhas que poderia ter descartado.
  • COUNT(*) conta linhas; COUNT(col) ignora NULLs; COUNT(DISTINCT col) conta valores.
  • SUM de nenhuma linha é NULL, não 0 — use COALESCE(SUM(x), 0) quando um relatório precisar de um número.
  • Toda coluna selecionada é agrupada ou agregada. O SQLite aceita uma coluna solta e escolhe uma linha; o PostgreSQL rejeita a consulta.
SELECT dept, COUNT(*) AS n,
  AVG(salary) AS avg_salary
FROM emp
WHERE salary >= 90
GROUP BY dept
HAVING COUNT(*) >= 3
1 linha
Resultado
deptnavg_salary
eng4110
SELECT COUNT(*) AS all_rows,
  COUNT(manager_id) AS has_manager,
  COUNT(DISTINCT salary) AS salaries
FROM emp
1 linha
Resultado
all_rowshas_managersalaries
765
SELECT SUM(amount) AS total,
  COALESCE(SUM(amount), 0) AS safe
FROM orders
WHERE customer_id = 2
1 linha
Resultado
totalsafe
NULL0

AulaAgregações e GROUP BYArtigoPL-300 vs DP-600: Power BI Data Analyst or Fabric Analytics Engineer

Funções de janela

f() OVER (PARTITION BY … ORDER BY …) calcula sobre linhas relacionadas e mantém todas as linhas. PARTITION BY reinicia o cálculo a cada grupo; ORDER BY define o “até agora”. As janelas rodam junto com SELECT, depois de WHERE — para filtrar por uma delas, envolva a consulta.

Funções de janela: o que cada uma retorna
FunçãoRetornaNos exemplos abaixo
ROW_NUMBER()1, 2, 3… — nunca repete. Os empates ficam em ordem arbitrária, a menos que o ORDER BY os desempate.Ben, Dev, Gus (todos 95) → 4, 5, 6
RANK()Empates dividem o mesmo número, e depois ele pula.95, 95, 95 → 4, 4, 4; Eve em seguida → 7
DENSE_RANK()Empates dividem o mesmo número, sem buracos — a função para o “N-ésimo maior valor”.95, 95, 95 → 4, 4, 4; Eve em seguida → 5
LAG(x [, k])x de k linhas atrás (padrão 1); NULL antes da primeira linha.prev em 09-02 → 40; em 09-01 → NULL
LEAD(x [, k])x de k linhas à frente; NULL depois da última linha.next em 09-01 → 55; em 09-04 → NULL
SUM(x) OVER (…)Com ORDER BY: uma soma acumulada. Só com PARTITION BY: o total do grupo em cada linha.so_far → 40, 95, 130, 185; dept_total de eng → 440 em cada linha de eng

Um ranking resolvido: três 95

ROW_NUMBER desempata pelo nome, RANK pula para 7 depois do empate, DENSE_RANK não pula.

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 linhas
Resultado
namesalaryrnrnkdrnk
Cleo130111
Ana120222
Finn100333
Ben95444
Dev95544
Gus95644
Eve80775

Vizinhos e uma soma acumulada

WINDOW w AS (…) dá nome a uma janela compartilhada por várias funções.

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

O total do grupo em cada linha

PARTITION BY sem ORDER BY: a resposta do GROUP BY, mantendo as linhas.

SELECT name, dept, salary,
  SUM(salary) OVER (
    PARTITION BY dept) AS dept_total
FROM emp
ORDER BY dept, name
7 linhas
Resultado
namedeptsalarydept_total
Anaeng120440
Beneng95440
Cleoeng130440
Guseng95440
Devops95275
Eveops80275
Finnops100275

O frame padrão e os empates

Com ORDER BY e sem frame definido, o frame da janela (window frame) é RANGE … CURRENT ROW: linhas empatadas na chave são somadas juntas, por isso os dois 55 mostram 185. Escreva ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW e elas mostram 130 e depois 185.

SELECT amount,
  SUM(amount) OVER (
    ORDER BY amount) AS t
FROM sale
ORDER BY amount
4 linhas
Resultado
amountt
3535
4075
55185
55185

AulaFunções de janelaArtigoRANK vs DENSE_RANK vs ROW_NUMBER: How Each Handles Ties

Subconsultas vs CTEs

Uma CTE é uma subconsulta com nome: o mesmo poder, lida de cima para baixo, utilizável duas vezes no mesmo comando. Só uma CTE recursiva faz algo que uma subconsulta não faz. Se uma CTE é calculada uma vez ou incorporada à consulta é escolha do banco (o PostgreSQL 12+ faz o inline de uma CTE usada uma vez, a menos que você escreva MATERIALIZED).

Formas de subconsulta e expressões de tabela comuns
FormaComo éComo rodaUse quando
Subconsulta escalarWHERE salary > (SELECT AVG(salary) FROM emp)Uma vez. Precisa retornar uma linha e uma coluna.Comparar com um único valor calculado.
IN / NOT INWHERE id IN (SELECT customer_id FROM orders)Uma vez, como lista.Pertencimento. Nunca use NOT IN sobre uma coluna que pode ter NULL.
EXISTS / NOT EXISTSWHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id)Por linha externa; para na primeira correspondência.Semi-joins e anti-joins; seguro com NULL.
Subconsulta correlacionadaWHERE salary > (SELECT AVG(salary) FROM emp WHERE dept = e.dept)Por linha externa (a menos que o planejador a reescreva).Curta de escrever; cuidado com o custo em tabelas grandes.
Tabela derivadaFROM (SELECT dept, AVG(salary) … GROUP BY dept) AS dUma vez, como uma tabela no FROM.Filtrar por uma agregação ou por um resultado de janela.
CTE (WITH)WITH dept_avg AS (SELECT …) SELECT … FROM dept_avgComo uma tabela derivada com nome.Vários passos, lidos de cima para baixo; um resultado usado duas vezes.
CTE recursivaWITH RECURSIVE chain AS (anchor UNION ALL step)A âncora uma vez, depois o passo até ele não retornar nada.Árvores e grafos: organogramas, listas de materiais, caminhos.

Mesma pergunta, três formatos: quem ganha mais que a média do seu 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 linhas
Resultado
name
Ana
Cleo
Dev
Finn

Tabela 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 linhas
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 linhas
Resultado
name
Ana
Cleo
Dev
Finn

AulasSubconsultasCTEs e recursãoArtigoEXISTS vs IN vs JOIN for "Is There a Match": Duplicates and NULLsArtigoCTE vs Subquery vs Temp Table: Readability, Reuse and Materialization

NULL

NULL significa desconhecido, então o SQL tem três valores lógicos: TRUE, FALSE e UNKNOWN. WHERE, ON e HAVING mantêm uma linha só quando o teste é TRUE — UNKNOWN é descartado como FALSE.

Lógica de três valores (o SQLite imprime TRUE como 1 e FALSE como 0)
ExpressãoResultadoPor quê
NULL = NULLNULLNão se sabe se dois valores desconhecidos são iguais.
NULL <> 1NULLQualquer comparação com NULL é desconhecida.
NULL AND FALSEFALSEFALSE, seja qual for o valor desconhecido.
NULL OR TRUETRUETRUE, seja qual for o valor desconhecido.
NOT NULLNULLO contrário de desconhecido continua desconhecido.
NULL IS NULLTRUEIS é o teste que consegue enxergar NULL.
1 IN (1, NULL)TRUEHouve uma correspondência.
2 IN (1, NULL)NULL2 = NULL é desconhecido, então não há um FALSE limpo.
2 NOT IN (1, NULL)NULL…e por isso NOT IN nunca é TRUE: a armadilha logo abaixo.

A armadilha do NOT IN

O pedido 4 tem customer_id NULL. Todo teste NOT IN então encontra um NULL e dá UNKNOWN, por isso Jon, que nunca fez pedido, não é retornado. NOT EXISTS é seguro com NULL.

SELECT name FROM customer
WHERE id NOT IN (
  SELECT customer_id FROM orders)
0 linha
Resultado
name
(nenhuma linha)
SELECT c.name FROM customer c
WHERE NOT EXISTS (
  SELECT 1 FROM orders o
  WHERE o.customer_id = c.id)
1 linha
Resultado
name
Jon

COALESCE

COALESCE(a, b, …) retorna o primeiro argumento que não é NULL. Jon não tem pedidos, então a soma da linha dele no LEFT JOIN é NULL — e aparece 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 linhas
Resultado
namespent
Ivy70
Jon0
Kai25
  • Chaves NULL nunca fazem join — nem com outro NULL.
  • GROUP BY põe todos os NULLs em um único grupo, e DISTINCT mantém um deles.
  • Ordenação: SQLite e MySQL põem NULL primeiro na ordem crescente (Ana, sem gerente, aparece primeiro aqui); o PostgreSQL o põe por último. Escreva NULLS FIRST ou NULLS LAST quando isso importar.

AulaWHERE e filtragemArtigoCHAR vs VARCHAR vs TEXT: Padding, Length Limits and Speed

Índices

Um índice é uma segunda cópia, ordenada, de algumas colunas — geralmente uma B-tree — com um ponteiro de volta para cada linha. Os planos abaixo são o EXPLAIN QUERY PLAN do SQLite em uma tabela de fotos com índice em (shot_by, year): SCAN lê todas as linhas, SEARCH vai direto ao ponto.

No que um índice ajuda e no que não ajuda
CasoConsultaPlano (SQLite)Por quê
Sem índice: varredura completaSELECT box FROM photo WHERE shot_by = 'Weiss'SCAN photoToda linha é lida e testada: O(n), seja qual for o tamanho da resposta.
O que um índice economizaSELECT box FROM photo WHERE shot_by = 'Weiss'SEARCH photo USING INDEX photo_by_year (shot_by=?)Uma busca na B-tree até a primeira correspondência, depois as correspondências: O(log n + k).
Composto: prefixo mais à esquerdaSELECT box FROM photo WHERE shot_by = 'Weiss' AND year = 1998SEARCH photo USING INDEX photo_by_year (shot_by=? AND year=?)Ordenado por shot_by e, dentro dele, por year: igualdade na primeira coluna, depois na segunda.
Ignorado: só a segunda colunaSELECT box FROM photo WHERE year = 1998SCAN photoyear só está ordenado dentro de cada shot_by, então não há um ponto para onde saltar.
Índice de coberturaSELECT year FROM photo WHERE shot_by = 'Weiss'SEARCH photo USING COVERING INDEX photo_by_year (shot_by=?)Toda coluna de que a consulta precisa está no índice, então a tabela nunca é lida.
Ignorado: função sobre a colunaSELECT box FROM photo WHERE lower(shot_by) = 'weiss'SCAN photoO índice está ordenado por shot_by, não por lower(shot_by). Reescreva a consulta ou indexe a expressão.
Ignorado: curinga no inícioSELECT box FROM photo WHERE shot_by LIKE '%eiss'SCAN photoUm padrão que pode começar com qualquer coisa não tem um ponto de partida ordenado.
ORDER BY atendido pelo índiceSELECT shot_by, year FROM photo ORDER BY shot_by, yearSCAN photo USING COVERING INDEX photo_by_yearAs linhas já saem ordenadas. Já ORDER BY box adiciona USE TEMP B-TREE FOR ORDER BY.
  • Custo: uma varredura é O(n); uma busca por índice é O(log n) mais os k resultados, mais uma busca da linha para cada um, a menos que o índice cubra a consulta.
  • Toda escrita paga: cada inserção, exclusão e atualização de uma coluna indexada também atualiza todos os índices que a contêm — O(log n) a mais por índice, e mais armazenamento.
  • O planejador pode ignorar um bom índice quando a consulta pega uma grande parte da tabela: uma única varredura sequencial pode ser melhor que muitas buscas de linha.
  • A ordem no índice composto importa: coloque primeiro a coluna que você sempre filtra com =; o índice atende qualquer prefixo mais à esquerda das suas colunas.

AulasÍndicesÍndices compostosComo ler um plano de execuçãoArtigoIndex vs Primary Key: The Rule and the Structure That Enforces ItArtigoComposite and Covering Indexes: Why Column Order MattersArtigoHow to Read a Query Plan: EXPLAIN in SQL, Line by Line

O problema N+1

Uma consulta para a lista, depois mais uma por linha. Cada uma é rápida; o custo está nas idas e voltas, e o número delas cresce com os dados — por isso passa com dez linhas e se arrasta com quinhentas. ORMs fazem isso por padrão quando uma relação usa lazy loading.

Comandos enviados para N jobs e suas partes
AbordagemComandosContados para 3 jobs
Uma consulta para a lista, uma por linha1 + N4
Um JOIN11
A lista, depois um WHERE job_id IN (…)22

Contados com o trace callback do SQLite, que registra cada comando que ele executa. Passe os ids da lista IN (…) como parâmetros, nunca os cole na consulta; indexe a chave estrangeira, ou cada uma das N consultas também será uma varredura, além de uma ida ao banco.

AulaO problema N+1ArtigoThe N+1 Query Problem: How to Spot It and Fix It

Transações e isolamento

Uma transação é uma unidade de trabalho. O nível de isolamento define quanto das outras transações, ainda não finalizadas, ela pode ver — cada degrau acima na escada elimina mais uma anomalia e custa um pouco de concorrência.

AAtomicidade
Todos os comandos são aplicados, ou nenhum; uma falha desfaz também os anteriores.
CConsistência
As restrições (CHECK, chaves estrangeiras, UNIQUE) valem antes e depois.
IIsolamento
Os outros não veem seu trabalho pela metade — com que rigor, quem define é o nível de isolamento.
DDurabilidade
Depois do commit, sobrevive a uma queda.
O que cada nível permite (os mínimos do padrão SQL)
NívelLeitura sujaLeitura não repetívelLeitura fantasmaEm uma linha
Read uncommittedPossívelPossívelPossívelVocê pode ler escritas de outra transação que ainda não tiveram commit.
Read committedImpedidaPossívelPossívelCada comando vê o que já tinha commit quando ele começou.
Repeatable readImpedidaImpedidaPossívelUma linha que você leu continua igual até você terminar.
SerializableImpedidaImpedidaImpedidaO resultado é igual ao de alguma ordem, uma transação por vez. Faça retry nas falhas de serialização.

Suja: você lê dados sem commit. Não repetível: uma linha que você leu duas vezes mudou. Fantasma: o conjunto de linhas que atende a uma condição mudou. Os bancos podem oferecer mais que o mínimo (o repeatable read do PostgreSQL também impede fantasmas), e os padrões variam: read committed no PostgreSQL, repeatable read no InnoDB do MySQL, e o SQLite executa toda transação como serializable.

AulasTransações e ACIDNíveis de isolamentoArtigoOptimistic vs Pessimistic Locking: SELECT FOR UPDATE vs Version ColumnArtigoSQL Isolation Levels Explained with Examples

Consultas de entrevista

As perguntas que aparecem sempre, cada uma nas tabelas de exemplo com as linhas que retornou.

  • Segundo maior salário

    O segundo maior salário distinto, ou NULL se não houver.

    SELECT MAX(salary) AS second
    FROM emp
    WHERE salary < (SELECT MAX(salary) FROM emp)
    1 linha
    Resultado
    second
    120

    Uma agregação sobre zero linhas é uma linha com NULL, então uma tabela com um só salário responde NULL, e não um resultado vazio.

    Aula
    Subconsultas · SQL
  • N-ésimo maior salário

    O terceiro maior salário distinto.

    SELECT DISTINCT salary
    FROM (
      SELECT salary, DENSE_RANK() OVER (
        ORDER BY salary DESC) AS r
      FROM emp) AS ranked
    WHERE r = 3
    1 linha
    Resultado
    salary
    100

    DENSE_RANK, não RANK: os três 95 empurrariam o RANK para além de 5 e deixariam buracos.

  • Encontrar duplicatas

    E-mails que se cadastraram mais de uma vez, e quantas vezes.

    SELECT email, COUNT(*) AS n
    FROM signup
    GROUP BY email
    HAVING COUNT(*) > 1
    ORDER BY email
    2 linhas
    Resultado
    emailn
    a@x.io3
    b@x.io2

    Para manter o primeiro de cada: DELETE FROM signup WHERE id NOT IN (SELECT MIN(id) FROM signup GROUP BY email) deixa os ids 1, 2, 4.

  • Linhas sem correspondência

    Clientes que nunca fizeram pedido.

    SELECT c.name
    FROM customer c
    WHERE NOT EXISTS (
      SELECT 1 FROM orders o
      WHERE o.customer_id = c.id)
    1 linha
    Resultado
    name
    Jon

    NOT IN (SELECT customer_id FROM orders) não retorna nenhuma linha aqui: o pedido 4 tem customer_id NULL.

  • Ganha mais que o próprio gerente

    Funcionários que ganham mais que a pessoa a quem se reportam.

    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 linhas
    Resultado
    namesalarymanager_salary
    Cleo130120
    Finn10095

    Um self-join: a mesma tabela duas vezes, com dois aliases. O inner join descarta a Ana, que não tem gerente.

  • Top N por grupo

    As duas pessoas mais bem pagas 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 linhas
    Resultado
    deptnamesalary
    engCleo130
    engAna120
    opsFinn100
    opsDev95

    Uma janela não pode ficar no WHERE, então ranqueie em uma subconsulta e filtre por fora. ROW_NUMBER dá exatamente N; DENSE_RANK mantém os empates (o top 3 em eng passa a ter 4 pessoas).

  • Soma acumulada

    Vendas acumuladas, dia a dia.

    SELECT day, amount,
      SUM(amount) OVER (
        ORDER BY day) AS total
    FROM sale
    ORDER BY day
    4 linhas
    Resultado
    dayamounttotal
    2026-09-014040
    2026-09-025595
    2026-09-0335130
    2026-09-0455185

    O frame padrão é RANGE: linhas empatadas na chave do ORDER BY dividem o mesmo total. Escreva ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW para uma soma estritamente linha a linha.

  • Três dias seguidos

    Pessoas que fizeram login em pelo menos três dias 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 linha
    Resultado
    person
    kim

    Duas linhas atrás só é exatamente dois dias atrás se cada linha for um dia diferente: remova antes os logins duplicados.

    Dialetojulianday() é do SQLite. Em colunas DATE do PostgreSQL, day - two_back = 2; no MySQL, DATEDIFF(day, two_back) = 2.

  • Lacunas e ilhas

    Agrupe os números de assento ocupados em sequências.

    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 linhas
    Resultado
    run_startrun_end
    13
    56
    99

    Dentro de uma sequência, o valor e o número da linha sobem juntos, então a diferença entre eles é constante: essa diferença é o grupo. As lacunas ficam entre um run_end e o run_start seguinte.

  • Todos abaixo de um gerente

    O organograma inteiro a partir do topo, com a profundidade de cada pessoa.

    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 linhas
    Resultado
    namedepth
    Ana0
    Ben1
    Cleo1
    Dev1
    Eve2
    Finn2
    Gus2

    A âncora, depois um passo que faz join de volta na CTE até não encontrar nada. Dados com ciclo nunca se esgotam: limite a profundidade ou guarde os ids já visitados.

    Aula
    CTEs e recursão · SQL

Erros comuns

bytepatterns.com/cheatsheets/sql — lá, cada linha leva a uma aula animada.