Formatar SQL

SQL (Structured Query Language) é a linguagem comum falada por quase todos os bancos de dados relacionais sérios do planeta—de PostgreSQL, MySQL, e SQLite até sistemas comerciais como SQL Server e Oracle. Permite definir estruturas de dados, armazenar dados, consultá-los eficientemente e impor regras sobre como esses dados se comportam.

A seguir está um tour aprofundado de cerca de 2.500 palavras sobre SQL: o que é, como funciona e como usá-lo bem em sistemas reais.

1. O que é SQL (e por que ainda é importante)

SQL é uma linguagem declarativa: você descreve quais dados quer, e o banco de dados decide como obtê-los. Tutoriais como o guia SQL no W3Schools e a série SQL do W3Schools.in apresentam SQL como uma linguagem padrão para armazenar, manipular e recuperar dados em muitos motores de banco de dados.

Como SQL é padronizado e amplamente suportado, você pode usar o mesmo modelo mental para:

• aplicações web em MySQL ou PostgreSQL
• aplicações embutidas usando SQLite
• sistemas empresariais como SQL Server ou Oracle

A maioria dos dados comerciais do dia a dia—pedidos, usuários, pagamentos, logs, análises—são eventualmente armazenados em tabelas que você pode consultar com SQL.

2. Padrões e dialetos SQL

SQL é padronizado pela família de padrões ISO/IEC 9075, que define a linguagem central e muitas extensões opcionais. O padrão evoluiu através de versões como SQL-86, SQL-92, SQL:1999, SQL:2003, e até SQL:2023. Artigos como a visão geral da ANSI sobre o padrão SQL ISO/IEC 9075:2023 explicam como os padrões ANSI e ISO se alinham ao longo do tempo.

O padrão em si é dividido em múltiplas partes, como:

• Parte 1 (Framework) e Parte 2 (Foundation)
• Parte 3 (Call-Level Interface) para APIs
• Parte 4 (Persistent Stored Modules) para procedimentos armazenados
• Partes posteriores como SQL/XML, SQL/MED, e até SQL/PGQ para consultas de grafos de propriedades

Você pode ver a lista completa na página do catálogo ISO para SQL e em recursos como a divisão do Modern SQL das partes do padrão.

Na prática, cada banco de dados implementa seu próprio dialeto:

• PostgreSQL adiciona extensões como tipos de dados avançados e busca de texto completo, documentadas no manual PostgreSQL.
• MySQL tem sua própria variante de declarações SQL e funções.
• SQLite suporta um subconjunto substancial de SQL com alguns comportamentos únicos, detalhados em sua documentação SELECT.

Os conceitos centrais—tabelas, linhas, colunas, junções, agregados—são portáteis, mas qualquer sistema não trivial envolverá aprender as peculiaridades e características de um dialeto específico.

3. Fundamentos relacionais: Tabelas, Linhas, Chaves

No coração, SQL é projetado em torno do modelo relacional: os dados vivem em tabelas (relações), onde cada linha representa um fato e cada coluna descreve um atributo.

Elementos típicos incluem:

• Tabela: ex. customers, orders
• Coluna: ex. id, name, order_date, total_amount
• Chave primária: um identificador único para cada linha (frequentemente um id)
• Chave estrangeira: uma coluna que referencia a chave primária de outra tabela (ex. orders.customer_id → customers.id)

Guias de normalização—como o tutorial de normalização do DigitalOcean ou a explicação do freeCodeCamp sobre 1NF, 2NF, 3NF—enquadram um bom design relacional como minimizar redundância e prevenir anomalias de atualização dividindo dados em tabelas bem estruturadas e vinculando-as com chaves.

Quando você consulta com SQL, essencialmente está perguntando ao banco de dados: "Dessas tabelas, sob essas condições, quais linhas e colunas devo ver?"

4. A consulta central: SELECT

A declaração SELECT é o cavalo de batalha do SQL e provavelmente seu comando mais complexo. A referência SELECT do SQLite a chama de "o comando mais complicado na linguagem SQL", e tanto a documentação SELECT do MySQL quanto tutoriais como o guia SELECT do SQLite Tutorial percorrem suas muitas opções.

SELECT id, name
FROM customers;

Partes principais:

• SELECT lista as colunas (ou * para todas as colunas, embora geralmente seja melhor ser explícito).
• FROM seleciona uma ou mais tabelas.
• WHERE filtra linhas.
• ORDER BY ordena os resultados.
• LIMIT limita quantas linhas você vê.

SELECT id, name, created_at
FROM customers
WHERE active = TRUE
ORDER BY created_at DESC
LIMIT 50;

Tutoriais introdutórios como o tutorial SQL do W3Schools e a visão geral do W3Schools MySQL sobre comandos comuns usam SELECT para mostrar como você extrai dados das tabelas em uma única expressão legível.

5. Filtragem, ordenação e expressões

SQL brilha quando você combina filtragem e expressões diretamente na consulta:

SELECT
 id,
 total_amount,
 total_amount * 0.1 AS tax_estimate
FROM orders
WHERE status = 'paid'
 AND total_amount >= 100
ORDER BY total_amount DESC;

A cláusula WHERE pode usar operadores de comparação (=, <>, >, <), operadores lógicos (AND, OR, NOT), correspondência de padrões (LIKE, ILIKE), e mais. Bancos de dados como MySQL documentam um rico conjunto de funções e operadores incorporados para operações numéricas, string, data/hora, JSON e outras.

Você também pode:

• usar IN para corresponder a uma lista: WHERE status IN ('paid', 'refunded')
• usar BETWEEN para intervalos: WHERE created_at BETWEEN '2025-01-01' AND '2025-01-31'
• usar IS NULL / IS NOT NULL para lidar com valores ausentes

Bons tutoriais e manuais enfatizam que expressões aparecem em muitas cláusulas— WHERE, ORDER BY, HAVING, e até mesmo SELECT mesmo. A documentação do MySQL destaca isso em sua seção sobre avaliação de expressões dentro do capítulo de funções e operadores.

6. Unindo tabelas

Bancos de dados reais raramente mantêm tudo em uma única tabela. Em vez disso, você normaliza os dados em múltiplas tabelas e os une quando consulta. Junções são amplamente cobertas em recursos como a página do W3Schools sobre junções SQL, tutorial de junções do GeeksforGeeks, visão geral de junções do TutorialsPoint, e guias interativos como o tutorial de junções SQL no SQL Practice Online.

SELECT
 id,
 c.name,
 o.order_date,
 o.total_amount
FROM orders AS o
JOIN customers AS c
 ON c.id = o.customer_id;

Tipos de junção comuns:

• INNER JOIN – apenas linhas com correspondências em ambas as tabelas
• LEFT JOIN – todas as linhas da tabela esquerda, mais correspondências da direita
• RIGHT JOIN – oposto da junção esquerda (não suportado em alguns motores como SQLite)
• FULL OUTER JOIN – linhas de ambos os lados, mesmo se não correspondentes

Explicações visuais e baseadas em código, como o artigo "SQL joins explained" do DbSchema ou os exemplos de junções do LearnSQL.com, são ótimas maneiras de construir uma forte intuição sobre como as junções se comportam.

7. Agregação, agrupamento e funções de janela

Para resumir dados—totais, médias, contagens—você usa funções de agregação (COUNT, SUM, AVG, MIN, MAX) com GROUP BY:

SELECT
 customer_id,
 COUNT(*) AS order_count,
 SUM(total_amount) AS total_spent
FROM orders
WHERE status = 'paid'
GROUP BY customer_id
HAVING SUM(total_amount) >= 1000
ORDER BY total_spent DESC;

Referências como o capítulo de funções e operadores do MySQL e a documentação do PostgreSQL sobre funções de agregação e janela catalogam as funções incorporadas que você pode usar nessas expressões.

SQL moderno também suporta funções de janela, que permitem calcular agregados sobre "janelas" deslizantes de linhas enquanto ainda retorna linhas individuais—por exemplo, totais acumulados ou classificações. Funções de janela entraram no SQL através de emendas ao SQL:1999, depois integradas no SQL:2003, como resumido em notas sobre os padrões SQL:1999 e SQL:2003.

SELECT
 customer_id,
 order_date,
 total_amount,
 SUM(total_amount) OVER (
   PARTITION BY customer_id
   ORDER BY order_date
 ) AS running_total
FROM orders;

Esse tipo de consulta é extremamente poderoso para análises diretamente no banco de dados.

8. Definição de dados: Criando e evoluindo esquemas

SQL não é apenas para consultar; também define a forma dos seus dados através de declarações Data Definition Language (DDL), bem documentadas em seções como o guia de Definição de Dados do PostgreSQL e o capítulo de declarações SQL do MySQL.

Comandos DDL comuns:

• CREATE DATABASE my_app; – criar um banco de dados
• CREATE TABLE customers (...); – definir uma tabela
• ALTER TABLE customers ADD COLUMN phone TEXT; – alterar a estrutura da tabela
• DROP TABLE customers; – remover uma tabela

CREATE TABLE customers (
 id           SERIAL PRIMARY KEY,
 email        VARCHAR(255) UNIQUE NOT NULL,
 name         TEXT NOT NULL,
 created_at   TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
 active       BOOLEAN NOT NULL DEFAULT TRUE
);

Pontos a notar:

• Tipos de dados: inteiros, strings, datas, booleanos, JSON, etc.
• Restrições: PRIMARY KEY, UNIQUE, NOT NULL, expressões CHECK
• Valores padrão e colunas geradas

Cada manual RDBMS principal—a seção de linguagem SQL do PostgreSQL, o manual de referência do MySQL, e a referência de linguagem do SQLite —enfatiza pensar cuidadosamente sobre DDL, porque decisões de esquema são difíceis de mudar depois.

9. Transações, concorrência e restrições

Bancos de dados SQL geralmente implementam as propriedades ACID—Atomicidade, Consistência, Isolamento, Durabilidade—através de transações:

BEGIN;

UPDATE accounts
SET balance = balance - 200
WHERE id = 1;

UPDATE accounts
SET balance = balance + 200
WHERE id = 2;

COMMIT;

Se algo falhar entre BEGIN e COMMIT, a transação pode ser revertida para que mudanças intermediárias não vazem para o banco de dados.

A seção do MySQL sobre declarações transacionais e de bloqueio cobre START TRANSACTION, COMMIT, ROLLBACK, e pontos de salvamento, enquanto os capítulos do PostgreSQL sobre controle de concorrência e gerenciamento de transações explicam como níveis de isolamento e MVCC funcionam sob o capô.

Restrições—como chaves estrangeiras ou restrições de verificação—são a maneira do banco de dados de impor regras de negócio:

ALTER TABLE orders
ADD CONSTRAINT fk_orders_customer
FOREIGN KEY (customer_id)
REFERENCES customers (id);

Usadas bem, transformam seu banco de dados em um guardião de invariantes, prevenindo dados inválidos na fonte em vez de depender apenas da lógica da aplicação.

10. Design de esquema e normalização

Fazer o esquema corretamente é frequentemente mais importante do que consultas inteligentes. Normalização é o processo de estruturar tabelas para reduzir redundância e melhorar a consistência. Tutoriais como:

• "Normalização de banco de dados em SQL — 1NF, 2NF, 3NF explicado"
• guia de normalização do DigitalOcean
• GeeksforGeeks sobre formas normais em DBMS
• visão geral do Guru99 sobre 1NF–6NF
• guia do Visual Paradigm sobre níveis de normalização

Progressão típica:

• 1NF: nenhum grupo repetitivo; cada coluna contém valores atômicos.
• 2NF: cada atributo não-chave depende de toda a chave primária (para chaves compostas).
• 3NF: nenhuma dependência transitiva (atributos não-chave não dependem de outros atributos não-chave).

A sobre-normalização pode prejudicar o desempenho e complicar as consultas; equipes pragmáticas frequentemente normalizam para 3NF e então desnormalizam seletivamente (por exemplo, armazenando em cache agregados) onde o desempenho o exige.

11. Índices e desempenho de consultas

Índices são a principal ferramenta para tornar as consultas SQL rápidas. São estruturas de dados auxiliares que permitem ao banco de dados pular diretamente para linhas relevantes em vez de escanear tabelas inteiras.

Um recurso muito respeitado sobre indexação é Use The Index, Luke! de Markus Winand, um livro online gratuito totalmente focado em desempenho SQL e estratégia de indexação. A página principal do site, UseTheIndexLuke.com, e artigos como "Indexing LIKE filters" e "More indexes, slower INSERT" explicam quando índices ajudam e quando prejudicam.

Ideias principais:

• Índices B-tree aceleram buscas de igualdade e intervalo (WHERE email = ..., WHERE created_at >= ...).
• Índices compostos consideram a ordem das colunas—por exemplo, (customer_id, created_at) funciona bem para WHERE customer_id = ? AND created_at >= ?.
• Índices ajudam SELECT, UPDATE, e DELETE com filtros, mas desaceleram inserções porque cada inserção deve atualizar todos os índices relevantes.

Guias como o artigo do MSSQLTips sobre projetar índices do SQL Server demonstram como a escolha e ordem das colunas em um índice impactam consultas reais.

Regras práticas:

• Indexe suas chaves primárias e colunas frequentes de junção/filtro.
• Evite indexar cada coluna—muitos índices matam o desempenho de escrita.
• Use EXPLAIN/EXPLAIN ANALYZE do banco de dados para ver como as consultas são executadas.

12. Recursos modernos do SQL: CTEs, JSON e além

Enquanto os fundamentos permaneceram estáveis, SQL moderno cresceu significativamente:

• Common Table Expressions (CTEs) via WITH permitem consultas mais legíveis e modulares:

  WITH recent_orders AS (
   SELECT *
   FROM orders
   WHERE order_date >= CURRENT_DATE - INTERVAL '7 days'
  )
  SELECT customer_id, COUNT(*) 
  FROM recent_orders
  GROUP BY customer_id;

• Suporte JSON permite misturar dados semi-estruturados com tabelas relacionais. PostgreSQL, MySQL e outros documentam funções JSON extensas em seus manuais, como os recursos JSON do MySQL listados sob funções JSON.
• Tipos de dados avançados (arrays, hstore, geometria, busca de texto completo) são descritos nos capítulos de tipos de dados e índices do PostgreSQL no manual PostgreSQL.

O próprio padrão SQL adicionou partes para XML, arrays multidimensionais e consultas de grafos de propriedades, como documentado no catálogo do padrão SQL ISO e em artigos sobre a evolução do SQL, como o artigo sobre o padrão SQL ANSI.

SQL moderno é poderoso o suficiente para que muitas aplicações possam empurrar lógica complexa—hierarquias, análises, processamento de eventos—para a camada do banco de dados.

13. Aprendendo SQL efetivamente

Como SQL permanece fundamental para o trabalho com dados, há um rico ecossistema de recursos de aprendizado:

• Tutoriais interativos como o tutorial SQL do W3Schools e o índice do curso SQL do W3Schools.in cobrem sintaxe, consultas e exemplos com um editor no navegador.
• Treinamentos estruturados como o treinamento SQL do W3Schools e SQL Bootcamp fornecem exercícios, avaliação automática e certificação.
• Sites baseados em prática como o tutorial de junções do SQL Practice Online e muitos outros dão problemas reais para resolver.
• Recursos especializados como Use The Index, Luke! focam em desempenho e indexação, preenchendo a lacuna entre SQL básico e ajuste de nível de produção.

Uma estratégia de aprendizado prática:

1. Domine SELECT e filtragem básica. Comece com consultas simples e gradualmente adicione WHERE, ORDER BY, e LIMIT.
2. Familiarize-se com junções. Pratique todos os tipos de junção até poder prever resultados com confiança.
3. Adicione agrupamento e agregação. Aprenda a responder perguntas como "receita por mês" ou "top 10 clientes" com GROUP BY.
4. Aprenda design de esquema. Estude normalização e pratique modelar sistemas reais—por exemplo, lojas, sistemas de reserva, redes sociais.
5. Explore os recursos do seu motor favorito. Leia a documentação oficial do seu banco de dados—a seção de linguagem SQL do PostgreSQL, o manual de referência do MySQL, ou a referência de linguagem do SQLite —para descobrir ferramentas específicas do motor.
6. Finalmente, aprenda desempenho. Experimente com índices usando os conceitos em Use The Index, Luke! e recursos similares, e perfile consultas com EXPLAIN.

Se você pode ler e escrever SQL confortavelmente, pode inspecionar dados diretamente em produção, construir relatórios sem exportar para planilhas, depurar lógica de aplicação olhando para as tabelas subjacentes, e colaborar mais efetivamente com engenheiros e analistas.

14. O quadro geral

SQL está em uma interseção única: tem mais de 40 anos, mas é profundamente relevante em sistemas cloud-native e pesados em análise hoje. O padrão ISO/IEC 9075 e suas muitas partes continuam evoluindo, enquanto bancos de dados open-source como PostgreSQL, MySQL, e SQLite impulsionam recursos práticos e melhorias de desempenho.

Se você trabalha com dados—desenvolvedor, analista, cientista de dados ou gerente de produto—SQL é a linguagem compartilhada que permite fazer perguntas diretamente ao banco de dados. Vale a pena aprender uma vez, e paga pelo resto da sua carreira.