Neste artigo
- O que é SQL e por que todo desenvolvedor precisa
- Seu primeiro SELECT: buscar e filtrar dados
- JOIN: como relacionar tabelas sem virar cartesiano
- GROUP BY e agregação: resumir em vez de arrastar
- Subqueries e CTEs: organizar consultas complexas
- Transações: por que consistência importa em produção
- ORM versus SQL cru: quando cada um vence
- Índices: a razão número um de banco rápido ou lento
- Como encontrar e corrigir uma query lenta
- O SQL na carreira de quem desenvolve
- Um roteiro de estudo para dominar SQL
- Preciso aprender SQL para ser desenvolvedor web?
- SQL é difícil para quem nunca viu banco de dados?
- Qual a diferença entre PostgreSQL e MySQL?
- O que é plano de execução?
- Índice sempre deixa a query mais rápida?
SQL é a habilidade de banco de dados que mais separa um dev funcional de um dev que trava a aplicação em produção. Você não precisa virar DBA, mas precisa entender o que a sua query faz no motor do banco. Este guia vai do primeiro SELECT até a análise de uma query lenta, com exemplos que rodam em PostgreSQL e MySQL.
SQL é a linguagem para consultar e transformar dados em banco relacional. O essencial para devs é dominar SELECT, JOIN, filtros, agregação com GROUP BY, subqueries e, depois, índices e plano de execução para corrigir query lenta. Uma referência completa de cada banco está nos guias de MySQL e de PostgreSQL.
O que é SQL e por que todo desenvolvedor precisa
SQL (Structured Query Language) é a interface padrão para bancos relacionais, onde os dados ficam organizados em tabelas com linhas e colunas. Quase toda aplicação com persistência fala SQL em algum ponto, mesmo quando o framework esconde a query atrás de um ORM. Quem não entende o que o ORM gera acaba descobrindo na pior hora, com o banco travado e o cliente reclamando.
Seu primeiro SELECT: buscar e filtrar dados
O SELECT é o comando de leitura. Você escolhe colunas, aponta a tabela e, opcionalmente, filtra com WHERE. O exemplo abaixo busca funcionários de um departamento específico.
SELECT nome, salario, departamento
FROM funcionarios
WHERE departamento = 'engenharia'
ORDER BY salario DESC
LIMIT 10;
Três detalhes mudam tudo na prática: liste só as colunas que você usa em vez de SELECT *, ordene só quando precisar e aplique o LIMIT para não arrastar milhares de linhas desnecessariamente. São hábitos de quem desenvolve pensando em banco, não em tela.
JOIN: como relacionar tabelas sem virar cartesiano
JOIN conecta tabelas por uma coluna em comum. O INNER JOIN devolve só as linhas que casam dos dois lados; o LEFT JOIN devolve tudo da tabela à esquerda e preenche com NULL onde não houver correspondência. A escolha errada produz resultados diferentes, não apenas mais lentos.
SELECT p.titulo, a.nome AS autor
FROM posts p
INNER JOIN autores a ON a.id = p.autor_id
WHERE p.publicado = true;
⚠️ Atenção: esquecer a condição do ON gera produto cartesiano: cada linha se cruza com todas as outras. Em tabelas grandes, o resultado explode em milissegundos e a query devolve dados sem sentido.
GROUP BY e agregação: resumir em vez de arrastar
Quando você precisa de totais, médias ou contagens, a agregação resolve no banco o que seria lento demais fazer na aplicação. GROUP BY agrupa linhas e as funções como COUNT, SUM e AVG resumem cada grupo.
SELECT departamento, COUNT(*) AS total, AVG(salario) AS media
FROM funcionarios
GROUP BY departamento
HAVING COUNT(*) > 5;
Repare no HAVING: ele filtra depois da agregação, enquanto o WHERE filtra antes. Trocar os dois é uma fonte clássica de bug em contagens. Deixe o banco agregar e traga para a aplicação só o resultado resumido.
Subqueries e CTEs: organizar consultas complexas
À medida que a consulta cresce, subqueries e CTEs (Common Table Expressions, o bloco WITH) ajudam a manter o SQL legível. Uma subquery devolve um conjunto temporário que a query externa consome. A CTE dá nome a esse conjunto e pode ser referenciada várias vezes.
WITH top_departamentos AS (
SELECT departamento, AVG(salario) AS media
FROM funcionarios
GROUP BY departamento
)
SELECT * FROM top_departamentos
ORDER BY media DESC;
A CTE não substitui memória de índice nem acelera mágicamente, mas torna a intenção legível para o próximo dev e para você mesmo em seis meses. Em bancos que aceitam, prefira CTE à subquery aninhada de cinco níveis.
Transações: por que consistência importa em produção
Transação agrupa várias operações para que ou todas aconteçam ou nenhuma. É o que impede aquele bug de dois registros em que um entra e o outro falha, deixando a base em estado inconsistente. Sem transação, uma transferência entre contas pode debitar de uma e nunca creditar na outra.
BEGIN;
UPDATE contas SET saldo = saldo - 100 WHERE id = 1;
UPDATE contas SET saldo = saldo + 100 WHERE id = 2;
COMMIT;
Se qualquer uma falhar, o banco pode voltar atrás com ROLLBACK e desfazer todo o bloco. Em aplicação web, o padrão correto é abrir a transação, executar os passos e commitar só ao final, nunca deixar o estado pela metade por conta de uma exceção no meio.
💡 Dica: teste o caminho de falha. Force um erro no segundo UPDATE e confira que o primeiro foi revertido. É o tipo de teste que pega bug de consistência que só aparece meses depois, na noite de sexta.
ORM versus SQL cru: quando cada um vence
O ORM acelera o CRUD e protege de erro de digitação, mas esconde o SQL que gera. Para o dia a dia, ele resolve; para consulta complexa, relatório ou migração de dados, o SQL cru vence em clareza e controle de performance. A regra prática é conhecer os dois e escolher pela leitura, não pelo dogma. Você não defende a stack inteira com fé, defende com a consulta certa no lugar certo.
Índices: a razão número um de banco rápido ou lento
Índice é a estrutura que permite ao banco achar linhas sem varrer a tabela inteira. A coluna usada com frequência em WHERE, JOIN e ORDER BY costuma merecer índice. Criar é simples; a arte está em saber qual e em não exagerar, porque cada índice custa escrita.
CREATE INDEX idx_funcionarios_departamento
ON funcionarios (departamento);
O trade-off é direto: índices aceleram leitura e deixam INSERT e UPDATE mais caros, porque o banco precisa manter a estrutura atualizada. Em tabela com muita escrita, índice demais degrada a gravação. Meça antes de criar.
Como encontrar e corrigir uma query lenta
O primeiro passo é descobrir o plano de execução, que mostra como o banco decide buscar os dados. No PostgreSQL, prefixe a query com EXPLAIN ANALYZE; no MySQL, use EXPLAIN. O plano revela se o banco varre a tabela toda (seq scan, o sinal clássico de índice ausente) ou se usa o índice.
EXPLAIN ANALYZE
SELECT * FROM pedidos
WHERE cliente_id = 42;
Três sinais você procura: seq scan em tabela grande, estimativa de linhas muito distante da real e operações de ordenação que não deveriam existir. Crie o índice da coluna do filtro e meça de novo. Não otimize de olho; o plano de execução é a única versão confiável do que o banco faz.
| Problema | Sintoma no plano | Correção |
|---|---|---|
| Índice ausente | Seq scan em tabela grande | Criar índice na coluna do filtro |
| Resultado bom demais | Estimação muito distante da real | Atualizar estatísticas do banco |
| JOIN mal planejado | Nested loop pesado | Garantir índice na chave estrangeira |
O SQL na carreira de quem desenvolve
SQL aparece em toda stack com banco relacional, e a cobrança só aumenta em vagas de backend e análise. É a base também de quem quer migrar para dados. Se o assunto é se especializar no tema, o caminho natural passa pelos guias de PostgreSQL, que é o relacional mais querido na comunidade, e de MySQL, o mais comum em sistemas legados e no mercado.
Um roteiro de estudo para dominar SQL
Se você quer sair do básico, siga uma ordem que acumula: primeiro as operações de leitura com filtro e ordenação, depois junção entre tabelas, depois agregação e subquery. Só então entre em modelagem, normalização e índices, que é onde o SQL passa a ser decisão de arquitetura. Por fim, feche o ciclo com plano de execução e análise de banco lento, porque é aí que a teoria vira resultado mensurável.
A constância vale mais que a intensidade: vinte minutos por dia consultando dados reais treinam mais que um fim de semana inteiro de vídeo. Quando o conceito estiver firme, mantenha um repositório com as suas consultas organizadas, porque a memória falha e o histórico de queries bem escritas é o seu melhor lembrete.
Para fechar o ciclo, valerá a pena separar um tempo para as decisões que não aparecem na consulta, mas sustentam o resultado: tipo de dado da coluna, chave primária, relacionamento entre tabelas e granularidade do índice. As boas práticas em banco de dados e SQL aplicadas ao Oracle mostram como essas escolhas de modelagem se comportam quando o volume cresce, e o raciocínio se transfere para PostgreSQL e MySQL com pouca adaptação.
Perguntas frequentes
Preciso aprender SQL para ser desenvolvedor web?
Se a aplicação persiste dados em banco relacional, sim. Mesmo com ORM, entender o SQL gerado evita consulta lenta e bug de integração que o framework não mostra.
SQL é difícil para quem nunca viu banco de dados?
O básico é linear e você produz resultado em um dia. A parte que leva tempo é o domínio de JOIN complexo, índice e plano de execução, que vem com prática em sistema real.
Qual a diferença entre PostgreSQL e MySQL?
Os dois são relacionais e falam SQL, mas o PostgreSQL é mais rico em tipos e recursos avançados, enquanto o MySQL é amplamente usado em sistemas mais antigos e na web. A escolha costuma vir do projeto, não de preferência isolada.
O que é plano de execução?
É o passo a passo que o banco planeja para resolver a sua query: quais tabelas lê, em que ordem e se usa índice. É a ferramenta básica para entender por que uma consulta demora.
Índice sempre deixa a query mais rápida?
Não. Ele acelera leitura mas encarece escrita, e índice que o banco não usa só ocupa espaço. Crie com base no que o filtro realmente pede e confirme no plano de execução.