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á.
| 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 |
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.
| Cláusula | O que faz | O que enxerga |
|---|---|---|
1FROM / JOIN | Monta as linhas: todas as tabelas, todos os joins. | Só as colunas das tabelas |
2WHERE | Mantém as linhas cujo teste dá TRUE. | Colunas — sem agregações, sem aliases do SELECT |
3GROUP BY | Condensa as linhas em uma linha por grupo. | Colunas |
4HAVING | Mantém os grupos cujo teste dá TRUE. | Agregações (SUM, COUNT…) |
5SELECT | Calcula as colunas de saída e nomeia os aliases; as funções de janela rodam aqui. | Tudo o que vem acima |
6DISTINCT | Descarta linhas de saída duplicadas. | As linhas de saída |
7ORDER BY | Ordena as linhas prontas. | Aliases e resultados de janela |
8LIMIT / OFFSET | Corta 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| name | doubled |
|---|---|
| Cleo | 260 |
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:
| id | name |
|---|---|
| 1 | Pepper |
| 2 | Rusty |
| 3 | Nell |
| dog_id | adopter |
|---|---|
| 1 | Yusuf |
| 1 | Omar |
| 3 | Marta |
| 4 | Ines |
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.id3 linhasResultado name adopter Pepper Omar Pepper Yusuf Nell Marta 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.id4 linhasResultado name adopter Pepper Omar Pepper Yusuf Rusty NULL Nell Marta 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.id4 linhasResultado name adopter Pepper Yusuf Pepper Omar Nell Marta NULL Ines 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.id5 linhasResultado name adopter Pepper Omar Pepper Yusuf Rusty NULL Nell Marta NULL Ines 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 adoptionSemi-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 linhasResultado 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 NULL1 linhaResultado 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 linhasResultado name adopter Pepper Yusuf Nell Marta
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 noHAVINGfunciona, 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| 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 |
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ção | Retorna | Nos 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| 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 |
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| 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 |
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| 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 |
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| amount | t |
|---|---|
| 35 | 35 |
| 40 | 75 |
| 55 | 185 |
| 55 | 185 |
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).
| Forma | Como é | Como roda | Use quando |
|---|---|---|---|
| Subconsulta escalar | WHERE salary > (SELECT AVG(salary) FROM emp) | Uma vez. Precisa retornar uma linha e uma coluna. | Comparar com um único valor calculado. |
| IN / NOT IN | WHERE 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 EXISTS | WHERE 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 correlacionada | WHERE 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 derivada | FROM (SELECT dept, AVG(salary) … GROUP BY dept) AS d | Uma 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_avg | Como uma tabela derivada com nome. | Vários passos, lidos de cima para baixo; um resultado usado duas vezes. |
| CTE recursiva | WITH 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| 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| 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 |
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.
| Expressão | Resultado | Por quê |
|---|---|---|
NULL = NULL | NULL | Não se sabe se dois valores desconhecidos são iguais. |
NULL <> 1 | NULL | Qualquer comparação com NULL é desconhecida. |
NULL AND FALSE | FALSE | FALSE, seja qual for o valor desconhecido. |
NULL OR TRUE | TRUE | TRUE, seja qual for o valor desconhecido. |
NOT NULL | NULL | O contrário de desconhecido continua desconhecido. |
NULL IS NULL | TRUE | IS é o teste que consegue enxergar NULL. |
1 IN (1, NULL) | TRUE | Houve uma correspondência. |
2 IN (1, NULL) | NULL | 2 = 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)| name |
|---|
| (nenhuma linha) |
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, …) 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| name | spent |
|---|---|
| Ivy | 70 |
| Jon | 0 |
| Kai | 25 |
- Chaves NULL nunca fazem join — nem com outro NULL.
- GROUP BY põe todos os NULLs em um único grupo, e
DISTINCTmanté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 FIRSTouNULLS LASTquando 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.
| Caso | Consulta | Plano (SQLite) | Por quê |
|---|---|---|---|
| Sem índice: varredura completa | SELECT box FROM photo
WHERE shot_by = 'Weiss' | SCAN photo | Toda linha é lida e testada: O(n), seja qual for o tamanho da resposta. |
| O que um índice economiza | SELECT 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 à esquerda | 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 e, dentro dele, por year: igualdade na primeira coluna, depois na segunda. |
| Ignorado: só a segunda coluna | SELECT box FROM photo
WHERE year = 1998 | SCAN photo | year só está ordenado dentro de cada shot_by, então não há um ponto para onde saltar. |
| Índice de cobertura | SELECT 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 coluna | SELECT box FROM photo
WHERE lower(shot_by) = 'weiss' | SCAN photo | O índice está ordenado por shot_by, não por lower(shot_by). Reescreva a consulta ou indexe a expressão. |
| Ignorado: curinga no início | SELECT box FROM photo
WHERE shot_by LIKE '%eiss' | SCAN photo | Um padrão que pode começar com qualquer coisa não tem um ponto de partida ordenado. |
| ORDER BY atendido pelo índice | SELECT shot_by, year FROM photo
ORDER BY shot_by, year | SCAN photo USING COVERING INDEX photo_by_year | As 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.
| Abordagem | Comandos | Contados para 3 jobs |
|---|---|---|
| Uma consulta para a lista, uma por linha | 1 + N | 4 |
| Um JOIN | 1 | 1 |
| A lista, depois um WHERE job_id IN (…) | 2 | 2 |
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.
| Nível | Leitura suja | Leitura não repetível | Leitura fantasma | Em uma linha |
|---|---|---|---|---|
| Read uncommitted | Possível | Possível | Possível | Você pode ler escritas de outra transação que ainda não tiveram commit. |
| Read committed | Impedida | Possível | Possível | Cada comando vê o que já tinha commit quando ele começou. |
| Repeatable read | Impedida | Impedida | Possível | Uma linha que você leu continua igual até você terminar. |
| Serializable | Impedida | Impedida | Impedida | O 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 linhaResultado 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
- Prática
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 = 31 linhaResultado salary 100 DENSE_RANK, não RANK: os três 95 empurrariam o RANK para além de 5 e deixariam buracos.
- Aula
- Funções de janela · SQL
- Prática
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 email2 linhasResultado email n a@x.io 3 b@x.io 2 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.
- Aula
- Agregações e GROUP BY · SQL
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 linhaResultado name Jon NOT IN (SELECT customer_id FROM orders) não retorna nenhuma linha aqui: o pedido 4 tem customer_id NULL.
- Aula
- JOINs INNER e OUTER · SQL
- Prática
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.name2 linhasResultado name salary manager_salary Cleo 130 120 Finn 100 95 Um self-join: a mesma tabela duas vezes, com dois aliases. O inner join descarta a Ana, que não tem gerente.
- Aula
- JOINs INNER e OUTER · SQL
- Prática
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, rn4 linhasResultado dept name salary eng Cleo 130 eng Ana 120 ops Finn 100 ops Dev 95 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).
- Aula
- Funções de janela · SQL
- Prática
Soma acumulada
Vendas acumuladas, dia a dia.
SELECT day, amount, SUM(amount) OVER ( ORDER BY day) AS total FROM sale ORDER BY day4 linhasResultado day amount total 2026-09-01 40 40 2026-09-02 55 95 2026-09-03 35 130 2026-09-04 55 185 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.
- Aula
- Funções de janela · SQL
- Prática
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) = 21 linhaResultado 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.
- Aula
- Funções de janela · SQL
- Prática
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_start3 linhasResultado run_start run_end 1 3 5 6 9 9 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.
- Aula
- Funções de janela · SQL
- Prática
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, name7 linhasResultado name depth Ana 0 Ben 1 Cleo 1 Dev 1 Eve 2 Finn 2 Gus 2 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
- Prática
- Usuários retidos mês a mêsDifícil
Erros comuns
- Um alias do SELECT ou uma agregação no WHEREHAVING para agregações; para aliases, repita a expressão ou filtre em uma consulta externa
- col = NULLcol IS NULL — uma comparação com NULL nunca é TRUE
- NOT IN sobre uma coluna que pode ter NULLNOT EXISTS, ou filtre os NULLs na subconsulta
- Um WHERE na tabela da direita depois de um LEFT JOINColoque a condição no ON, ou as linhas sem par somem
- SUM ou COUNT sobre um join que multiplica linhasAgregue primeiro o lado “muitos”, depois faça o join
- COUNT(col) quando você queria contar linhasCOUNT(*) conta linhas; COUNT(col) ignora NULLs
- LIMIT sem ORDER BYSem ORDER BY não há ordem: as linhas mantidas são as que vieram primeiro
- RANK para “exatamente N por grupo”ROW_NUMBER para exatamente N; RANK e DENSE_RANK mantêm empates
- Uma função sobre uma coluna indexadaCompare a coluna pura, ou indexe a expressão
- Uma consulta dentro de um loopUm JOIN, ou um WHERE id IN (…) para a lista inteira
- Ler, calcular na aplicação e gravar de voltaFaça a conta em um único UPDATE, ou dois atendentes causam uma atualização perdida (lost update)
bytepatterns.com/cheatsheets/sql — lá, cada linha leva a uma aula animada.