SQL para análise de dados · Guias · 30 de outubro de 2026 · 11 min de leitura

Comandos SQL básicos: SELECT, WHERE, ORDER BY, GROUP BY e JOIN para iniciantes

Uma consulta SQL básica tem sempre a mesma forma: SELECT diz quais colunas você quer ver, FROM de qual tabela elas vêm, WHERE filtra as linhas, GROUP BY agrupa as linhas para calcular totais, ORDER BY ordena o resultado e JOIN combina duas tabelas por uma coluna em comum. Com esses seis comandos você resolve a maior parte do trabalho diário de um analista. Este guia passa por cada um deles com consultas que funcionam de verdade: todas rodam no banco de dados de uma companhia aérea usado no curso de SQL da Nomto, e cada resultado mostrado abaixo é a saída real.

O banco de dados dos exemplos

Vamos trabalhar com cinco tabelas de uma companhia aérea (os textos dos dados estão em inglês, os valores em dólares americanos e os horários no horário-base da companhia, Moscou, UTC+3):

Antes de escrever qualquer consulta, vale saber o que representa uma linha de cada tabela. Quase todos os erros de iniciante em SQL vêm de contar linhas que não são o que a gente imagina.

SELECT e FROM: escolher colunas

A consulta mais simples pede colunas de uma tabela:

SELECT model, range
FROM aircrafts;

Algumas regras que vale fixar desde o começo:

• SELECT * devolve todas as colunas. Serve para dar uma olhada, mas numa consulta de verdade liste as colunas de que você precisa: o resultado fica mais claro e não quebra se alguém acrescentar colunas à tabela.
• No SELECT você pode fazer cálculos. Com AS você dá um nome à coluna calculada.
• O ponto e vírgula no final separa consultas. Na sala de SQL da Nomto roda uma consulta por vez, então você pode omiti-lo.

O alcance está em quilômetros. Se quisermos também em milhas:

SELECT model,
       range,
       ROUND(range / 1.609) AS range_miles
FROM aircrafts
ORDER BY range DESC
LIMIT 5;

Sem ROUND, a coluna sairia cheia de casas decimais (6.898,69484151647). ORDER BY e LIMIT aparecem mais abaixo.

WHERE: filtrar linhas

O WHERE deixa passar só as linhas que atendem a uma condição. Os aeroportos de Moscou:

SELECT airport_code, airport_name, city
FROM airports
WHERE city = 'Moscow'
ORDER BY airport_code;

Repare em dois detalhes: o texto vai entre aspas simples (no PostgreSQL as aspas duplas são para nomes de colunas) e a comparação diferencia maiúsculas de minúsculas: 'moscow' não devolve nada.

Combinar condições: AND, OR, IN, BETWEEN

As partidas de Sheremetyevo em 1º de agosto:

SELECT flight_no, scheduled_departure, arrival_airport, status
FROM flights
WHERE departure_airport = 'SVO'
  AND scheduled_departure >= '2026-08-01'
  AND scheduled_departure <  '2026-08-02'
ORDER BY scheduled_departure, flight_no
LIMIT 5;

Nesse dia saíram 50 voos de SVO. O filtro de datas segue o padrão “maior ou igual ao início do dia e menor que o início do dia seguinte”. É mais seguro que BETWEEN '2026-08-01' AND '2026-08-01', que em colunas de data e hora só pega o instante exato da meia-noite.

O IN substitui vários OR sobre a mesma coluna. Os voos que já decolaram (no ar ou já pousados):

SELECT COUNT(*)
FROM flights
WHERE status IN ('Departed', 'Arrived');

O resultado é 16.765. Quando misturar AND e OR, use parênteses: o AND é avaliado primeiro, e a OR b AND c significa a OR (b AND c).

LIKE: buscar por padrão

% substitui qualquer quantidade de caracteres e _ substitui exatamente um. As cidades que começam com “Novo”:

SELECT airport_code, airport_name, city
FROM airports
WHERE city LIKE 'Novo%'
ORDER BY city;

No PostgreSQL, o ILIKE faz o mesmo sem diferenciar maiúsculas de minúsculas.

IS NULL: valores vazios

NULL significa “sem valor”. Um voo que ainda não saiu tem actual_departure vazio. Aqui está a armadilha mais famosa do SQL:

SELECT COUNT(*) FROM flights WHERE actual_departure = NULL;   -- 0
SELECT COUNT(*) FROM flights WHERE actual_departure IS NULL;  -- 16348

A primeira devolve 0, embora existam milhares de voos que ainda não saíram: qualquer comparação com NULL dá “desconhecido”, e o WHERE só deixa passar o que é verdadeiro. Para valores vazios, use sempre IS NULL ou IS NOT NULL.

ORDER BY e LIMIT: ordenar e ficar com as primeiras linhas

Sem ORDER BY, o banco de dados devolve as linhas na ordem que for mais conveniente para ele, e essa ordem pode mudar de uma execução para outra. As cinco reservas mais caras:

SELECT book_ref, book_date, total_amount
FROM bookings
ORDER BY total_amount DESC
LIMIT 5;

• ASC (o padrão) ordena do menor para o maior; DESC, do maior para o menor.
• Você pode ordenar por várias colunas: ORDER BY scheduled_departure, flight_no desempata pelo número do voo quando dois saem no mesmo horário, como no exemplo de SVO.
• LIMIT sem ORDER BY devolve “algumas linhas quaisquer”, não “as primeiras”. Se importa quais linhas aparecem, ordene.

Funções de agregação: COUNT, SUM, AVG, MIN, MAX

As funções de agregação transformam muitas linhas num único número. Uma diferença que vale entender logo cedo:

SELECT COUNT(*)                          AS total,
       COUNT(actual_departure)           AS departed,
       COUNT(*) - COUNT(actual_departure) AS not_yet
FROM flights;

COUNT(*) conta linhas; COUNT(coluna) conta só os valores não vazios. COUNT(DISTINCT coluna) conta valores distintos: SELECT COUNT(DISTINCT timezone) FROM airports devolve 17 fusos horários.

GROUP BY: um total por grupo

O GROUP BY divide a tabela em grupos e calcula a agregação dentro de cada um. Quantos voos existem em cada status:

SELECT status, COUNT(*) AS flights
FROM flights
GROUP BY status
ORDER BY flights DESC;

Várias agregações de uma vez, por classe tarifária:

SELECT fare_conditions,
       COUNT(*)              AS segments,
       ROUND(AVG(amount), 2) AS avg_price,
       MIN(amount)           AS min_price,
       MAX(amount)           AS max_price
FROM ticket_flights
GROUP BY fare_conditions
ORDER BY avg_price DESC;

Em média, um trecho na executiva custa $511,43, e na econômica, $159,60. A regra de ouro: toda coluna do SELECT precisa estar no GROUP BY ou dentro de uma função de agregação. Se você escrever SELECT status, flight_no, COUNT(*) ... GROUP BY status, o PostgreSQL dá erro, porque num grupo há centenas de números de voo e ele não sabe qual mostrar.

HAVING: filtrar grupos

O WHERE filtra linhas antes de agrupar; o HAVING filtra grupos depois. As cidades com mais de um aeroporto:

SELECT city, COUNT(*) AS airports
FROM airports
GROUP BY city
HAVING COUNT(*) > 1
ORDER BY airports DESC;

Não dá para escrever WHERE COUNT(*) > 1: quando o WHERE é avaliado, os grupos ainda não existem. A diferença entre os dois está detalhada no guia de GROUP BY e HAVING.

JOIN: combinar tabelas

Na tabela flights, o avião aparece só como código (321, SU9). O nome do modelo está em aircrafts. O JOIN une as duas tabelas pela coluna em comum:

SELECT a.model, COUNT(*) AS flights
FROM flights f
JOIN aircrafts a ON a.aircraft_code = f.aircraft_code
GROUP BY a.model
ORDER BY flights DESC;

f e a são aliases: nomes curtos para não repetir o nome inteiro da tabela. O ON diz quais linhas andam juntas.

INNER JOIN e LEFT JOIN

A tabela acima tem 8 modelos, mas em aircrafts há 9. O JOIN (que é o INNER JOIN) fica só com as linhas que têm par nas duas tabelas, então o modelo sem voos some. O LEFT JOIN mantém todas as linhas da tabela da esquerda e preenche com NULL o que não encontra. É assim que se procuram “linhas sem par”:

SELECT a.aircraft_code, a.model
FROM aircrafts a
LEFT JOIN flights f ON f.aircraft_code = a.aircraft_code
WHERE f.flight_id IS NULL;

Se for contar com LEFT JOIN, use COUNT(f.flight_id) e não COUNT(*): assim o A320 aparece com 0, e não com 1.

Um aviso para quando você avançar: se você junta uma tabela com outra que tem várias linhas para cada linha da primeira (uma reserva com vários bilhetes), as linhas se multiplicam e as somas ficam infladas. Explicamos isso com números no guia de JOIN no SQL e nas perguntas de entrevista SQL.

Tudo junto: uma consulta completa

Os comandos se combinam numa ordem fixa: SELECT … FROM … JOIN … WHERE … GROUP BY … HAVING … ORDER BY … LIMIT. Cidades com pelo menos 300 voos já pousados e o atraso médio de partida, em minutos:

SELECT ap.city,
       COUNT(*) AS flights,
       ROUND(AVG(EXTRACT(EPOCH FROM f.actual_departure - f.scheduled_departure) / 60), 1) AS avg_delay_min
FROM flights f
JOIN airports ap ON ap.airport_code = f.departure_airport
WHERE f.status = 'Arrived'
GROUP BY ap.city
HAVING COUNT(*) >= 300
ORDER BY avg_delay_min DESC;

A subtração de duas datas dá um intervalo; EXTRACT(EPOCH FROM …) converte esse intervalo em segundos, e dividimos por 60.

Em que ordem uma consulta é executada

A gente escreve o SELECT primeiro, mas o banco de dados o processa quase no fim:

1. FROM e JOIN: monta a tabela de trabalho.
2. WHERE: descarta linhas.
3. GROUP BY: forma os grupos.
4. HAVING: descarta grupos.
5. SELECT: calcula as colunas e os aliases.
6. ORDER BY: ordena (aqui você já pode usar os aliases do SELECT).
7. LIMIT: corta.

Essa ordem explica por que um alias do SELECT funciona no ORDER BY, mas não no WHERE, e por que as agregações vão no HAVING.

Erros comuns de iniciante

• = NULL em vez de IS NULL. Devolve zero linhas sem nenhum aviso.
• Aspas duplas para texto. WHERE city = "Moscow" no PostgreSQL procura uma coluna chamada Moscow.
• Colunas não agrupadas no SELECT. Tudo o que não estiver no GROUP BY precisa ir dentro de uma agregação.
• LIMIT sem ORDER BY. O resultado não é “o top”, é aleatório.
• COUNT(*) depois de um LEFT JOIN. Conta como 1 as linhas sem par.
• Datas com BETWEEN em colunas com hora. Use >= início e < dia seguinte.

Como praticar

Ler consultas ajuda, mas se aprende escrevendo e errando. Todos os exemplos deste guia podem ser executados e modificados na sala de SQL da Nomto, com o mesmo banco de dados: troque a cidade, o status ou a ordenação e veja o que acontece. O primeiro módulo do curso começa justamente por SELECT e aliases, e cada aula termina com três exercícios corrigidos automaticamente. Quando dominar o básico, siga para os exercícios de SQL com respostas e para as funções de janela.

Perguntas frequentes

Quanto tempo leva para aprender os comandos SQL básicos?

SELECT, WHERE, ORDER BY, GROUP BY e JOIN podem ser aprendidos em duas ou três semanas praticando uma hora por dia. O que leva mais tempo é ler bem os dados: saber o que é uma linha e quando um JOIN multiplica linhas.

Qual a diferença entre WHERE e HAVING?

O WHERE filtra linhas antes de agrupar e não aceita agregações. O HAVING filtra os grupos já formados e é usado com COUNT, SUM, AVG e companhia.

O SQL deste guia serve para MySQL ou SQL Server?

Quase tudo, sim. SELECT, WHERE, GROUP BY, HAVING, JOIN e ORDER BY são iguais em todos os sistemas. Mudam detalhes: no SQL Server, LIMIT vira TOP; ILIKE não existe no MySQL nem no SQL Server; e as funções de data têm nomes diferentes.

Preciso instalar um banco de dados para praticar?

Não. Na sala de SQL da Nomto você escreve a consulta no navegador e a executa no banco de dados da companhia aérea, sem instalar nada.

Outros idiomas: English, Tiếng Việt, 简体中文, Español