# Como Aprender SQL de Graça: Um Plano Baseado em Prática com Queries Reais > Cursos, sites de prática e bancos de dados de exemplo gratuitos para aprender SQL passo a passo, do SELECT às window functions. Source: https://www.erathos.com/blog/como-aprender-sql-de-graca Published: 2026-09-12 Category: Tutoriais ![Como Aprender SQL de Graça](https://cms-media.erathos.com/Como Aprender SQL de Graça.png) SQL é a linguagem que você usa para fazer perguntas a um banco de dados. Na [pesquisa Stack Overflow Developer Survey de 2025](https://survey.stackoverflow.co/2025/technology), 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](https://www.iso.org/standard/76583.html), 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](https://cs50.harvard.edu/sql/) é gratuito para fazer pela página OpenCourseWare, e um certificado verificado só vem pelo edX. O [Learn SQL da Codecademy](https://www.codecademy.com/learn/learn-sql) 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](https://github.com/lerocha/chinook-database) 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](https://www.erathos.com/en/blog/data-types-in-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. Curso Custo Banco de dados que ensina Formato Duração declarada pelo curso [SQLBolt](https://sqlbolt.com/) Grátis Estilo SQLite, no navegador Aulas e exercícios interativos Não informado [Khan Academy: Intro to SQL](https://www.khanacademy.org/computing/computer-programming/sql) Grátis No navegador Vídeos mais desafios interativos Não informado [CS50 SQL (Harvard)](https://cs50.harvard.edu/sql/) Grátis; certificado via edX é pago SQLite, mais PostgreSQL e MySQL depois Aulas, listas de exercícios, projeto final Sete semanas de material [Kaggle: Intro to SQL](https://www.kaggle.com/learn/intro-to-sql) Grátis Google BigQuery Tutoriais em notebook e exercícios 3 horas [Codecademy: Learn SQL](https://www.codecademy.com/learn/learn-sql) Aulas grátis; certificado é pago No navegador Aulas interativas 5 horas [Mode SQL Tutorial](https://mode.com/sql-tutorial/) Grátis Editor próprio do Mode 15 aulas básicas, 20 intermediárias, 9 avançadas, mais 8 de analytics Não informado [freeCodeCamp: Relational Database](https://www.freecodecamp.org/learn/relational-database/) Grátis PostgreSQL em um terminal Baseado em projeto, usa Bash e VS Code Não informado [freeCodeCamp SQL video course](https://www.youtube.com/watch?v=HXV3zeQKqGY) Grátis MySQL Um único vídeo no YouTube 4 horas e 20 minutos [W3Schools SQL](https://www.w3schools.com/sql/) Grátis MySQL, SQL Server, PostgreSQL, Oracle, Access Páginas de referência com editor Try It Não informado [SQLZoo](https://sqlzoo.net/wiki/SQL_Tutorial) Grátis, login opcional No navegador Tutorial estilo wiki com exercícios Não informado 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. Site de prática Custo Banco de dados O que você ganha [LeetCode SQL 50](https://leetcode.com/studyplan/top-sql-50/) Plano de estudos grátis Vários engines para escolher 50 questões de SQL montadas como um plano de preparação para entrevista [PostgreSQL Exercises](https://pgexercises.com/) Grátis (conteúdo é CC BY-SA 3.0) PostgreSQL Questões de SELECT e WHERE até joins, agregação, window functions e queries recursivas, tudo em um único conjunto de dados de um clube de campo [HackerRank SQL](https://www.hackerrank.com/domains/sql) Grátis Vários engines Problemas agrupados em Basic Select, Advanced Select, Aggregation, Basic Join, Advanced Join e Alternative Queries, marcados de Easy a Hard [Stack Exchange Data Explorer](https://data.stackexchange.com/) Grátis SQL Server (T-SQL) Escreva queries contra dados públicos reais do Stack Overflow 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](https://data.stackexchange.com/help) 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: Sandbox Engines disponíveis [sqliteonline.com](https://sqliteonline.com/) SQLite, MariaDB, PostgreSQL, MS SQL [sqlfiddle.com](https://sqlfiddle.com/) SQL Server, SQLite, PostgreSQL, MySQL, MariaDB, Oracle [db-fiddle.com](https://www.db-fiddle.com/) Fiddles gratuitos; fiddles privados precisam do plano pago PRO [shell.duckdb.org](https://shell.duckdb.org/) DuckDB, com conjuntos de dados de exemplo carregados (NYC Taxi em Parquet, Star Trek CSV, serviços de trem) ## 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](https://sqlite.org/copyright.html), então não há licença para aceitar. O [shell de linha de comando sqlite3](https://sqlite.org/cli.html) 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](https://sqlitebrowser.org/) é 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`](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](https://duckdb.org/docs/stable/clients/cli/overview.html) é 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: Banco de dados gratuito na nuvem O que o plano gratuito inclui Fique atento a [BigQuery sandbox](https://docs.cloud.google.com/bigquery/docs/sandbox) 1 TiB de processamento de consultas por mês, 10 GiB de armazenamento, sem cartão de crédito O limite de armazenamento de 10 GiB é vitalício e não é devolvido quando você deleta dados [Supabase Free](https://supabase.com/pricing) US$ 0, PostgreSQL, requisições de API ilimitadas Projetos pausam depois de 1 semana de inatividade; limite de 2 projetos ativos [Neon Free](https://neon.com/pricing) US$ 0, PostgreSQL, 100 projetos, 100 horas de computação por projeto por mês 0,5 GB de armazenamento por projeto 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. Conjunto de dados Tamanho e formato Onde conseguir Chinook 11 tabelas de uma loja de música digital: 59 clientes, 412 faturas, 3.503 faixas, 275 artistas [Releases no GitHub](https://github.com/lerocha/chinook-database), scripts para seis engines de banco de dados Sakila Banco de dados de exemplo oficial do MySQL, uma locadora de DVDs [Documentação do MySQL](https://dev.mysql.com/doc/sakila/en/) Northwind Exemplo clássico de empresa comercial da Microsoft [SQL Server samples da Microsoft no GitHub](https://github.com/microsoft/sql-server-samples/tree/master/samples/databases/northwind-pubs) Dados do Stack Exchange Dados públicos ao vivo de todo site do Stack Exchange [data.stackexchange.com](https://data.stackexchange.com/), consultado em T-SQL Conjuntos de dados públicos do BigQuery Muitos conjuntos de dados públicos grandes hospedados pelo Google [cloud.google.com/bigquery/public-data](https://cloud.google.com/bigquery/public-data), grátis dentro dos limites do sandbox Registros de corridas de táxi de Nova York Horários e locais de embarque e desembarque, distâncias, tarifas, formas de pagamento, em arquivos Parquet [NYC Taxi and Limousine Commission](https://www.nyc.gov/site/tlc/about/tlc-trip-record-data.page) 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](https://survey.stackoverflow.co/2025/technology), 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: Tarefa SQLite / PostgreSQL MySQL SQL Server Retornar as primeiras 5 linhas LIMIT 5 (o PostgreSQL também aceita [FETCH FIRST 5 ROWS ONLY](https://www.postgresql.org/docs/current/sql-select.html)) LIMIT 5 [SELECT TOP 5](https://learn.microsoft.com/en-us/sql/t-sql/queries/top-transact-sql) Juntar duas strings O operador de pipe duplo, como em FirstName || ' ' || LastName CONCAT(); o pipe duplo significa OR a menos que o modo [PIPES\_AS\_CONCAT](https://dev.mysql.com/doc/refman/8.4/en/sql-mode.html) esteja ativo CONCAT() ou + Colocar um nome de coluna entre aspas Aspas duplas [Crases](https://dev.mysql.com/doc/refman/8.4/en/identifiers.html), a menos que o modo ANSI\_QUOTES esteja ativo [Colchetes ou aspas duplas](https://learn.microsoft.com/en-us/sql/relational-databases/databases/database-identifiers) Data de hoje [date('now')](https://sqlite.org/lang_datefunc.html) no SQLite, CURRENT\_DATE no PostgreSQL [CURDATE()](https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html) [GETDATE()](https://learn.microsoft.com/en-us/sql/t-sql/functions/getdate-transact-sql) retorna um datetime 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](https://www.kaggle.com/learn/intro-to-sql), o Learn SQL da Codecademy com [5 horas](https://www.codecademy.com/learn/learn-sql), e o CS50 SQL tem [sete semanas de material](https://cs50.harvard.edu/sql/) 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](https://www.erathos.com/en/blog/data-centralization-without-a-dedicated-team) 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](https://www.erathos.com/en/blog/etl-vs-elt-key-differences) 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](https://www.erathos.com/en/blog/what-is-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](https://app.erathos.com/signup).