SQL para análise: fundamentos que todo profissional deveria dominar
Aprenda os fundamentos de SQL para consultar, filtrar, agrupar e analisar dados com exemplos práticos.
SQL é a habilidade mais citada em vagas de dados. Em descrições de trabalho para analistas, engenheiros, cientistas e profissionais de produto, SQL aparece com uma consistência que não depende de tendências nem de ferramentas da moda.
O motivo é simples: a maior parte dos dados organizados em empresas ainda vive em bancos de dados relacionais, e SQL é a linguagem para trabalhar com eles. Entender SQL não é sobre decorar sintaxe — é sobre conseguir fazer perguntas aos dados e obter respostas.
Este artigo cobre os fundamentos de SQL com foco em análise de dados. A ideia não é ser uma referência completa da linguagem, mas ensinar o suficiente para você escrever consultas úteis, entender os resultados e continuar aprendendo com mais contexto.
O que você vai aprender
- O que é SQL e onde ele é usado.
- Como estruturar uma consulta básica.
- Como filtrar e ordenar resultados.
- Como calcular totais, médias e contagens.
- Como agrupar dados para análise por categoria.
- Como combinar dados de duas tabelas com JOIN.
- Boas práticas para escrever consultas legíveis.
- Erros comuns de quem está começando.
O que é SQL
SQL — Structured Query Language — é uma linguagem declarativa para interagir com bancos de dados relacionais. “Declarativa” significa que você descreve o que quer, não como o banco de dados deve buscar: você escreve SELECT produto FROM pedidos WHERE status = 'entregue' e o banco cuida de como recuperar esses dados.
SQL é usado para consultar dados (extrair, filtrar, agrupar), para inserir ou atualizar registros e para criar estruturas de tabelas. Em análise de dados, o foco principal está nas consultas — o SELECT.
A linguagem foi criada nos anos 1970 e continua sendo o padrão para bancos de dados relacionais. PostgreSQL, MySQL, SQLite, BigQuery, Redshift e Snowflake — todos suportam SQL, com variações pequenas de sintaxe. Os fundamentos que você aprende aqui funcionam em qualquer um deles.
O dataset dos exemplos
Para deixar os exemplos práticos e consistentes, vamos usar duas tabelas fictícias ao longo de todo o artigo.
A tabela pedidos registra compras realizadas:
| id | cliente_id | produto | valor | status | data_pedido |
|---|---|---|---|---|---|
| 1 | 1 | Notebook | 2800 | entregue | 2026-01-10 |
| 2 | 2 | Mouse | 80 | pendente | 2026-01-12 |
| 3 | 1 | Teclado | 150 | entregue | 2026-01-15 |
| 4 | 3 | Monitor | 1200 | cancelado | 2026-01-18 |
| 5 | 2 | Notebook | 2800 | entregue | 2026-01-20 |
A tabela clientes tem os dados dos compradores:
| id | nome | cidade |
|---|---|---|
| 1 | Ana | São Paulo |
| 2 | Bruno | Rio de Janeiro |
| 3 | Carlos | Belo Horizonte |
A estrutura básica de uma consulta
Uma consulta SQL começa com SELECT — o que você quer buscar — e FROM — de onde buscar.
SELECT produto, valor
FROM pedidos;
Essa consulta retorna as colunas produto e valor de todos os registros da tabela pedidos.
Para selecionar todas as colunas, use SELECT *:
SELECT *
FROM pedidos;
Na prática, prefira nomear as colunas em vez de usar *. Consultas com SELECT * são mais difíceis de ler e podem retornar dados desnecessários em tabelas grandes.
Filtrando linhas com WHERE
Para filtrar os registros que atendem a uma condição, use WHERE:
SELECT produto, valor, status
FROM pedidos
WHERE status = 'entregue';
Esta consulta retorna apenas os pedidos com status = 'entregue' — os pedidos de id 1, 3 e 5.
Você pode combinar condições com AND e OR:
SELECT produto, valor
FROM pedidos
WHERE status = 'entregue'
AND valor > 500;
Outros operadores comuns:
!=ou<>— diferente de>,<,>=,<=— comparações numéricasLIKE— busca por padrão de texto; o%representa qualquer sequência de caracteres —'Note%'encontra qualquer valor que comece com “Note”, como “Notebook”IN— pertence a uma lista de valoresBETWEEN— dentro de um intervalo inclusivoIS NULL— valor nulo
Em SQL, NULL não pode ser comparado com =. Use sempre IS NULL:
-- incorreto — nunca retorna resultados
WHERE coluna = NULL
-- correto
WHERE coluna IS NULL
-- Pedidos pendentes ou cancelados
SELECT produto, valor, status
FROM pedidos
WHERE status IN ('pendente', 'cancelado');
-- Pedidos com valor entre 100 e 2000
SELECT produto, valor
FROM pedidos
WHERE valor BETWEEN 100 AND 2000;
Ordenando resultados com ORDER BY
Para definir a ordem dos resultados, use ORDER BY:
SELECT produto, valor
FROM pedidos
ORDER BY valor DESC;
DESC ordena do maior para o menor. ASC (padrão, quando omitido) ordena de forma crescente — do menor para o maior em números, de A a Z em texto.
É possível ordenar por múltiplas colunas:
SELECT status, produto, valor
FROM pedidos
ORDER BY status ASC, valor DESC;
Agregando dados: COUNT, SUM, AVG, MIN, MAX
Funções de agregação calculam um valor resumido a partir de um conjunto de linhas.
COUNT — conta registros:
-- Total de pedidos na tabela
SELECT COUNT(*) AS total_pedidos
FROM pedidos;
-- Total de pedidos entregues
SELECT COUNT(*) AS total_entregues
FROM pedidos
WHERE status = 'entregue';
COUNT(*) conta todas as linhas, incluindo as com valores nulos. COUNT(coluna) conta apenas as linhas em que aquela coluna tem um valor não nulo.
SUM — soma valores:
SELECT SUM(valor) AS receita_total
FROM pedidos
WHERE status = 'entregue';
AVG — média:
SELECT AVG(valor) AS ticket_medio
FROM pedidos;
MIN e MAX — menor e maior valor:
SELECT MIN(valor) AS menor_pedido, MAX(valor) AS maior_pedido
FROM pedidos;
O AS cria um alias — um nome mais legível para a coluna no resultado.
Agrupando com GROUP BY
Funções de agregação sozinhas calculam um valor para todos os registros da consulta. GROUP BY divide os registros em grupos e aplica a agregação a cada grupo separadamente.
SELECT status, COUNT(*) AS quantidade
FROM pedidos
GROUP BY status;
Resultado:
| status | quantidade |
|---|---|
| entregue | 3 |
| pendente | 1 |
| cancelado | 1 |
Você pode agrupar por múltiplas colunas e combinar com WHERE:
SELECT produto, COUNT(*) AS quantidade, SUM(valor) AS total
FROM pedidos
WHERE status = 'entregue'
GROUP BY produto
ORDER BY total DESC;
Regra importante: toda coluna no SELECT que não for uma função de agregação deve aparecer no GROUP BY. Se você inclui produto no SELECT, ele deve estar no GROUP BY.
Filtrando grupos com HAVING
WHERE filtra linhas antes do agrupamento. HAVING filtra grupos após o agrupamento.
-- Produtos com mais de 1 pedido entregue
SELECT produto, COUNT(*) AS quantidade
FROM pedidos
WHERE status = 'entregue'
GROUP BY produto
HAVING COUNT(*) > 1;
Neste exemplo:
WHERE status = 'entregue'filtra as linhas antes de agrupar — só pedidos entregues entram no cálculo;HAVING COUNT(*) > 1filtra os grupos resultantes, mantendo apenas produtos com mais de uma ocorrência.
A distinção é relevante para a performance e para a correção do resultado: tente usar WHERE sempre que a condição se aplica às linhas individuais, e reserve HAVING para condições sobre grupos.
Combinando tabelas com JOIN
Bancos de dados relacionais organizam dados em tabelas separadas para evitar repetição. A tabela pedidos usa cliente_id para referenciar a tabela clientes, em vez de repetir nome e cidade em cada pedido.
Para combinar informações das duas tabelas em uma única consulta, usamos JOIN.
INNER JOIN retorna apenas os registros que têm correspondência nas duas tabelas:
SELECT p.produto, p.valor, c.nome, c.cidade
FROM pedidos AS p
INNER JOIN clientes AS c ON p.cliente_id = c.id;
A cláusula ON define a condição de correspondência: pedidos.cliente_id deve ser igual a clientes.id. AS p e AS c são aliases de tabela — simplificam a escrita quando referenciamos colunas de múltiplas tabelas.
O resultado combina as colunas das duas tabelas para cada par correspondente:
| produto | valor | nome | cidade |
|---|---|---|---|
| Notebook | 2800 | Ana | São Paulo |
| Mouse | 80 | Bruno | Rio de Janeiro |
| Teclado | 150 | Ana | São Paulo |
| Monitor | 1200 | Carlos | Belo Horizonte |
| Notebook | 2800 | Bruno | Rio de Janeiro |
LEFT JOIN retorna todos os registros da tabela da esquerda, mesmo sem correspondência na direita:
SELECT p.produto, c.nome
FROM pedidos AS p
LEFT JOIN clientes AS c ON p.cliente_id = c.id;
Se um pedido não tiver um cliente_id correspondente em clientes, ele ainda aparece no resultado — com NULL nas colunas de clientes. Um INNER JOIN descartaria esse pedido.
Boas práticas para consultas legíveis
Palavras-chave em maiúsculo. SELECT, FROM, WHERE, GROUP BY em maiúsculo facilitam a leitura quando a consulta cresce.
Uma cláusula por linha. Organize a consulta em linhas para facilitar leitura e edição:
SELECT
status,
COUNT(*) AS quantidade,
SUM(valor) AS total
FROM pedidos
WHERE data_pedido >= '2026-01-01'
GROUP BY status
ORDER BY total DESC;
Aliases descritivos. Use AS para nomear colunas calculadas com nomes que fazem sentido fora do contexto da consulta.
Comentários para contexto. Use -- para comentários de linha quando a lógica não é óbvia:
-- Total de receita por produto em pedidos entregues
SELECT produto, SUM(valor) AS receita
FROM pedidos
WHERE status = 'entregue' -- exclui cancelados e pendentes
GROUP BY produto;
Evite SELECT * em produção. Selecione apenas as colunas que você precisa — a consulta fica mais rápida, mais legível e menos suscetível a quebrar quando o schema da tabela muda.
Erros comuns de iniciantes
Usar = NULL em vez de IS NULL. Em SQL, NULL não é comparável com =. A condição WHERE coluna = NULL nunca retorna resultados, independentemente dos dados. Use sempre WHERE coluna IS NULL.
Confundir WHERE e HAVING. WHERE filtra linhas antes do agrupamento; HAVING filtra grupos após o agrupamento. Usar HAVING onde deveria ser WHERE produz resultados iguais em alguns casos, mas é mais lento e comunica a intenção errada.
Esquecer que JOIN pode multiplicar linhas. Se a tabela de destino tiver múltiplos registros correspondentes para uma linha da tabela de origem, o resultado terá mais linhas do que o esperado. Verifique a cardinalidade do relacionamento antes de confiar no resultado.
SELECT * em consultas de produção. Além de retornar dados desnecessários, quebra silenciosamente se alguém adicionar, remover ou reordenar colunas na tabela.
Não filtrar em tabelas grandes. Uma consulta sem WHERE em uma tabela com milhões de linhas pode travar o ambiente de análise. Sempre filtre antes de agregar ou exportar.
Colunas sem alias. COUNT(*) sem alias retorna uma coluna com nome genérico dependente do banco de dados. Use COUNT(*) AS total para deixar explícito o que aquela coluna representa.
Próximos passos
A melhor forma de solidificar SQL é praticar com dados reais. Algumas opções de ambiente:
- PostgreSQL instalado localmente é a referência mais próxima do que você vai encontrar no mercado;
- SQLite funciona como um arquivo, sem necessidade de configurar um servidor — ideal para experimentos iniciais;
- Ferramentas online como DB Fiddle, SQLiteOnline e Mode SQL Editor permitem escrever e executar SQL direto no navegador, sem instalação.
O próximo artigo da série cobre modelagem de dados — como estruturar tabelas de forma que as consultas de análise sejam mais simples, precisas e reutilizáveis. SQL e modelagem caminham juntos: escrever boas consultas fica muito mais fácil quando os dados estão bem organizados.
Conclusão
SQL tem uma curva de aprendizado acessível e retorno rápido. Com SELECT, WHERE, GROUP BY e JOIN, você já consegue responder a maioria das perguntas analíticas do dia a dia.
O próximo passo não é memorizar mais sintaxe — é praticar com dados que importam para você. Escolha um dataset, formule uma pergunta, escreva a consulta, ajuste o que não funcionar. É assim que SQL se torna uma ferramenta natural de trabalho.