Como Aprender SQL de Graça: Um Plano Baseado em Prática com Queries Reais

SQL é a linguagem que você usa para fazer perguntas a um banco de dados. Na pesquisa Stack Overflow Developer Survey de 2025, 58,6% de todos os respondentes disseram que usaram SQL no último ano. Só JavaScript e HTML/CSS pontuaram mais alto. A boa notícia para quem está aprendendo: o melhor material é grátis, os bancos de dados são grátis, e os dados de prática são grátis. Este guia lista o que a gente usaria, em que ordem, e mostra as queries rodando em um banco de dados real.

Dá para aprender SQL de graça?

Sim. Cursos gratuitos baseados em navegador como SQLBolt, Khan Academy e o CS50 SQL de Harvard cobrem tudo, desde um primeiro SELECT até window functions, e SQLite e DuckDB te dão um banco de dados grátis no seu próprio laptop. Você só paga se quiser um certificado.

SQL é um padrão aberto. A versão atual é a ISO/IEC 9075-1:2023, publicada em junho de 2023. Todo banco de dados importante (PostgreSQL, MySQL, SQLite, SQL Server, BigQuery) segue a maior parte desse padrão, então o que você aprende em um vale para os outros com pequenas mudanças. Cobrimos essas mudanças na seção de dialetos abaixo.

A única coisa que dinheiro compra é um certificado. O curso SQL do CS50 é gratuito para fazer pela página OpenCourseWare, e um certificado verificado só vem pelo edX. O Learn SQL da Codecademy está marcado como Free na página do curso, e o certificado de conclusão está no plano pago. As aulas são as mesmas dos dois jeitos.

Em que ordem você deve aprender SQL?

Aprenda SQL nesta ordem: SELECT e FROM, depois WHERE e ORDER BY, depois GROUP BY com COUNT e SUM, depois JOIN, depois subqueries e CTEs, depois window functions. Cada passo reutiliza o anterior, e todo curso gratuito deste guia segue mais ou menos o mesmo caminho.

Para mostrar como esse caminho se parece, rodamos cada passo contra o banco de dados Chinook. Chinook é um banco de dados de exemplo gratuito que modela uma loja de música digital, com scripts para SQLite, PostgreSQL, MySQL, SQL Server, Oracle e DB2. O arquivo SQLite tem cerca de 1 MB. Estas são as tabelas dele:

Album Customer Genre InvoiceLine Playlist Track
Artist Employee Invoice MediaType PlaylistTrack

O passo um é escolher colunas de uma tabela e limitar quantas linhas voltam:

SELECT Name
FROM Artist
LIMIT 5;

╭───────────────────╮
│ Name │
╞═══════════════════╡
│ AC/DC │
│ Accept │
│ Aerosmith │
│ Alanis Morissette │
│ Alice In Chains │
╰───────────────────╯

O passo dois filtra linhas com WHERE e as ordena com ORDER BY. Aqui encontramos faixas com mais de dez minutos e convertemos milissegundos para minutos no SELECT:

SELECT Name, Milliseconds / 60000.0 AS minutes
FROM Track
WHERE Milliseconds > 600000
ORDER BY Milliseconds DESC
LIMIT 5;

╭─────────────────────────────┬────────────────────╮
│ Name │ minutes │
╞═════════════════════════════╪════════════════════╡
│ Occupation / Precipice │ 88.115883333333329 │
│ Through a Looking Glass │ 84.813966666666673 │
│ Greetings from Earth, Pt. 1 │ 49.338216666666668 │
│ The Man With Nine Lives │ 49.2833 │
│ Battlestar Galactica, Pt. 2 │ 49.268016666666668 │
╰─────────────────────────────┴────────────────────╯

O passo três agrupa linhas e as conta. GROUP BY colapsa os 59 clientes em uma linha por país, e HAVING filtra na contagem depois do agrupamento:

SELECT Country, COUNT(*) AS customer_count
FROM Customer
GROUP BY Country
HAVING COUNT(*) > 5
ORDER BY customer_count DESC;

╭─────────┬────────────────╮
│ Country │ customer_count │
╞═════════╪════════════════╡
│ USA │ 13 │
│ Canada │ 8 │
╰─────────┴────────────────╯

A cláusula HAVING existe porque WHERE roda antes do agrupamento. Se você tentar filtrar no agregado dentro do WHERE, o SQLite te barra:

SELECT CustomerId, SUM(Total) AS total_spent
FROM Invoice
WHERE total_spent > 20
GROUP BY CustomerId;

Parse error near line 3: misuse of aggregate: SUM()

O passo quatro junta duas tabelas por uma chave compartilhada. Album tem uma coluna ArtistId que aponta para Artist, então o join pareia cada álbum com o seu artista:

SELECT Album.Title, Artist.Name AS artist
FROM Album JOIN Artist
ON Album.ArtistId = Artist.ArtistId
ORDER BY Album.AlbumId
LIMIT 5;

╭───────────────────────────────────────┬───────────╮
│ Title │ artist │
╞═══════════════════════════════════════╪═══════════╡
│ For Those About To Rock We Salute You │ AC/DC │
│ Balls to the Wall │ Accept │
│ Restless and Wild │ Accept │
│ Let There Be Rock │ AC/DC │
│ Big Ones │ Aerosmith │
╰───────────────────────────────────────┴───────────╯

O passo cinco é uma CTE, uma common table expression. Ela nomeia uma consulta com WITH para que você possa usá-la como uma tabela na consulta seguinte. Esta soma a receita por país, depois escolhe os três primeiros:

WITH country_revenue AS (
SELECT BillingCountry AS country, ROUND(SUM(Total), 2) AS revenue
FROM Invoice GROUP BY BillingCountry
)
SELECT country, revenue FROM country_revenue
ORDER BY revenue DESC LIMIT 3;

╭─────────┬─────────╮
│ country │ revenue │
╞═════════╪═════════╡
│ USA │ 523.06 │
│ Canada │ 303.96 │
│ France │ 195.1 │
╰─────────┴─────────╯

O passo seis é window functions. RANK() OVER (PARTITION BY Country ...) classifica clientes dentro do próprio país sem colapsar linhas como o GROUP BY faz. Aqui mantemos o maior gastador por país:

WITH totals AS (
SELECT c.CustomerId, c.Country,
c.FirstName || ' ' || c.LastName AS customer,
ROUND(SUM(i.Total), 2) AS total_spent
FROM Customer c JOIN Invoice i USING (CustomerId)
GROUP BY c.CustomerId
), ranked AS (
SELECT *, RANK() OVER (PARTITION BY Country ORDER BY total_spent DESC) AS country_rank
FROM totals
)
SELECT Country, customer, total_spent, country_rank
FROM ranked WHERE country_rank = 1
ORDER BY Country LIMIT 5;

╭───────────┬─────────────────┬─────────────┬──────────────╮
│ Country │ customer │ total_spent │ country_rank │
╞═══════════╪═════════════════╪═════════════╪══════════════╡
│ Argentina │ Diego Gutiérrez │ 37.62 │ 1 │
│ Australia │ Mark Taylor │ 37.62 │ 1 │
│ Austria │ Astrid Gruber │ 42.62 │ 1 │
│ Belgium │ Daan Peeters │ 37.62 │ 1 │
│ Brazil │ Luís Gonçalves │ 39.62 │ 1 │
╰───────────┴─────────────────┴─────────────┴──────────────╯

Depois que esses seis passos parecerem normais, o resto do SQL é detalhe: tipos de dados, tratamento de NULL, e as diferenças entre bancos de dados. Nosso guia sobre tipos de dados em SQL cobre o primeiro desses.

Quais cursos gratuitos de SQL valem seu tempo?

Para um iniciante completo, o SQLBolt ensina o básico no navegador sem cadastro, o Intro to SQL da Khan Academy adiciona vídeo, e o CS50 SQL de Harvard vai mais fundo de graça. O Intro to SQL do Kaggle é a escolha se você quer aprender no BigQuery, um warehouse real na nuvem.

Algumas notas sobre como escolher. O SQLBolt é a forma mais rápida de escrever sua primeira query, porque as aulas começam com partes de um SELECT e os exercícios rodam na mesma página. O CS50 SQL é o único da lista com listas de exercícios corrigidas e um projeto final; submetê-los precisa de uma conta gratuita no edX. O curso Relational Database do freeCodeCamp é o diferente do grupo: ensina PostgreSQL através de um terminal junto com Bash, e o freeCodeCamp diz que essa seção não está mais sendo atualizada.

O curso em vídeo do freeCodeCamp tem mais de 20 milhões de visualizações e dura 4 horas e 20 minutos. É uma boa aula de fundo, mas um vídeo sozinho não vai construir o hábito de digitar queries. Combine com uma das opções interativas.

Onde você pode praticar SQL de graça?

Para praticar SQL de graça, use o plano de estudos SQL 50 do LeetCode para problemas estilo entrevista, o PostgreSQL Exercises para um único conjunto de dados realista que vai até window functions e queries recursivas, e o domínio SQL do HackerRank para problemas corrigidos organizados por tópico. Os três rodam no navegador sem instalação.

O Stack Exchange Data Explorer é o mais interessante dos quatro porque os dados são reais e grandes. É uma ferramenta open source para rodar queries arbitrárias contra dados públicos de todo site do Stack Exchange, e você pode começar a partir de queries que outras pessoas já compartilharam.

Quando você quer digitar SQL sem configurar nada, sandboxes no navegador te dão um banco de dados vazio:

Qual banco de dados gratuito você deveria instalar para aprender SQL?

Instale o SQLite primeiro, depois o DuckDB. O SQLite é de domínio público, vem como um único programa de linha de comando, e lê o arquivo Chinook usado neste artigo sem precisar configurar um servidor. O DuckDB também é um único arquivo, e consegue consultar um CSV diretamente sem etapa de importação.

O SQLite é de domínio público, então não há licença para aceitar. O shell de linha de comando sqlite3 abre um arquivo de banco de dados ou um em memória e te deixa digitar queries em um prompt. Se você prefere clicar a digitar, o DB Browser for SQLite é um app desktop gratuito com uma visão estilo planilha das tabelas.

Para reproduzir os exemplos acima, baixe o arquivo SQLite do Chinook na página de releases do projeto e abra:

curl -fL https://github.com/lerocha/chinook-database/releases/download/v1.4.5/Chinook_Sqlite.sqlite \
-o Chinook_Sqlite.sqlite
sqlite3 Chinook_Sqlite.sqlite

Depois ligue os headers e o estilo de saída em caixa, e toda query deste artigo vai imprimir da mesma forma:

.headers on
.mode box
SELECT COUNT(*) AS customers FROM Customer;

O DuckDB CLI é um único executável sem dependências, pré-compilado para Windows, Mac e Linux. Seu melhor truque para quem está aprendendo é consultar arquivos diretamente. Exportamos a tabela Customer para um CSV a partir do SQLite, depois pedimos ao DuckDB para agrupá-lo sem criar uma tabela:

SELECT Country, COUNT(*) AS n
FROM 'customers.csv'
GROUP BY Country
ORDER BY n DESC
LIMIT 5;

┌─────────┬───────┐
│ Country │ n │
│ varchar │ int64 │
├─────────┼───────┤
│ USA │ 13 │
│ Canada │ 8 │
│ Brazil │ 5 │
│ France │ 5 │
│ Germany │ 4 │
└─────────┴───────┘

Isso significa que qualquer CSV que você já tenha (um export de uma planilha, um extrato bancário, um relatório de vendas) vira um banco de dados de prática em uma linha.

Quando você quer praticar em um banco de dados que roda na nuvem, os planos gratuitos abaixo não custam nada e não precisam de cartão de crédito para o sandbox do BigQuery:

O BigQuery é o que a gente escolheria para alguém que quer sentir como é um data warehouse. O curso Intro to SQL do Kaggle roda nele, e o Google hospeda conjuntos de dados públicos que você consegue consultar na hora.

Quais conjuntos de dados gratuitos você pode usar para praticar SQL?

Chinook, Sakila e Northwind são os clássicos bancos de dados de exemplo pequenos, e o Stack Exchange Data Explorer, os conjuntos de dados públicos do BigQuery e os registros de corridas de táxi de Nova York dão dados reais em escala. Comece pequeno para conseguir conferir suas respostas na mão, depois avance para os grandes.

As contagens de linhas do Chinook acima vêm de rodar COUNT(*) no arquivo SQLite. Números pequenos como esses são o ponto: quando um GROUP BY diz que os EUA têm 13 clientes, você consegue rolar a tabela Customer e contar você mesmo.

Qual dialeto de SQL você deveria aprender primeiro?

Aprenda em SQLite ou PostgreSQL primeiro. O SQLite é a instalação menor, e o PostgreSQL é o banco de dados mais usado na pesquisa Stack Overflow de 2025, com 55,6% de todos os respondentes. Os dois usam sintaxe padrão para as coisas que mais diferem entre bancos de dados: limite de linhas, junção de strings, e como colocar nomes entre aspas.

O núcleo do SQL (SELECT, WHERE, GROUP BY, JOIN, CTEs, window functions) é o mesmo em todo lugar. As diferenças que pegam iniciantes estão nos detalhes pequenos:

A linha de concatenação de strings é a que mais morde. Esta query funciona igual no SQLite e no DuckDB:

SELECT FirstName || ' ' || LastName AS full_name
FROM Customer
LIMIT 3;

╭───────────────────╮
│ full_name │
╞═══════════════════╡
│ Luís Gonçalves │
│ Leonie Köhler │
│ François Tremblay │
╰───────────────────╯

No MySQL com configurações padrão, o mesmo pipe duplo é um OR lógico, então você escreveria CONCAT(FirstName, ' ', LastName) em vez disso. O DuckDB aceita as duas formas e retornou os mesmos três nomes para cada uma.

Quanto tempo leva para aprender SQL?

Os próprios cursos gratuitos colocam o básico em algumas horas e um curso completo em algumas semanas. O Intro to SQL do Kaggle é listado com 3 horas, o Learn SQL da Codecademy com 5 horas, e o CS50 SQL tem sete semanas de material com listas de exercícios.

Esses números cobrem as aulas. Ficar confortável vem da repetição em dados com que você se importa, e é por isso que os sites de prática e os conjuntos de dados acima importam mais do que qual curso você escolhe. Um plano viável é um curso interativo para cobrir os seis passos, depois uma lista de exercícios (LeetCode SQL 50 ou PostgreSQL Exercises) até joins e GROUP BY pararem de precisar de pensar, depois um conjunto de dados real que você explora sem nenhuma tarefa.

Onde o SQL te leva depois?

Assim que você conseguir escrever essas queries, a próxima pergunta é onde estão os dados que você quer consultar. Na maioria das empresas eles estão espalhados por um CRM, uma ferramenta de pagamentos, uma central de suporte, e algumas planilhas. O jeito habitual de resolver isso é copiar tudo para um único warehouse (BigQuery, Snowflake, Redshift ou Databricks) e apontar seu SQL para lá. Nosso guia sobre centralização de dados sem um time de dados dedicado percorre essa configuração.

A etapa de carga é o que os times de dados chamam de ELT: extrair da fonte, carregar no warehouse, depois transformar com SQL. Nossa comparação de ETL vs. ELT explica por que a transformação se moveu para o final, e por que isso fez do SQL a habilidade principal para trabalhar com dados de warehouse. Ferramentas como o Metabase então deixam você transformar essas queries em dashboards.

A Erathos é a camada de carga nessa stack. Ela se conecta às suas fontes e entrega as tabelas no seu warehouse, para que o SQL que você acabou de aprender tenha algo real para rodar. Experimente a Erathos grátis por 14 dias.