SQL do Zero

SQL (Structured Query Language) controla bancos de dados relacionais. Seja no SQLite, PostgreSQL, MySQL ou SQL Server, a maioria dos comandos básicos é a mesma. Este artigo cria tabelas, insere dados, faz buscas, combina tabelas, agrupa resultados e altera dados, usando SQLite para não precisar de servidor.

Todos os comandos aqui foram executados com SQLite 3.50 e a saída mostrada é real.

O que você precisa

SQLite (verifique com `sqlite3 --version`) ou o DB Browser for SQLite, que é gratuito

Como as tabelas se relacionam

Diagrama das tabelas students, classes e scores ligadas por chaves

Criando tabelas e inserindo dados

CREATE TABLE students (
  id INTEGER PRIMARY KEY,
  name TEXT NOT NULL,
  class_id INTEGER
);
CREATE TABLE classes (
  id INTEGER PRIMARY KEY,
  title TEXT NOT NULL
);
CREATE TABLE scores (
  student_id INTEGER REFERENCES students(id),
  subject TEXT,
  score INTEGER
);
INSERT INTO classes VALUES (1, 'X-1'), (2, 'X-2');
INSERT INTO students VALUES (1, 'Budi', 1), (2, 'Siti', 1), (3, 'Andi', 2);
INSERT INTO scores VALUES (1, 'Matemática', 85), (1, 'Inglês', 70), (2, 'Matemática', 72), (3, 'Matemática', 45), (3, 'Inglês', 60);

`PRIMARY KEY` dá a cada linha uma chave única.
`NOT NULL` exige que exista um valor.
`REFERENCES` liga as tabelas, então `scores.student_id` precisa existir em `students`.

Buscando com SELECT e WHERE

SELECT name FROM students WHERE class_id = 1;

Combinando tabelas com JOIN

SELECT s.name, c.title FROM students s JOIN classes c ON c.id = s.class_id ORDER BY s.name;

`JOIN` combina linhas de duas tabelas quando as chaves coincidem. `s` e `c` são apelidos curtos para as tabelas.

Agrupando com GROUP BY

SELECT subject, AVG(score) AS media, COUNT(*) AS n FROM scores GROUP BY subject ORDER BY subject;

Funções de agregação como `AVG`, `COUNT` e `SUM` trabalham sobre cada grupo. Use `HAVING` para filtrar depois do agrupamento:

SELECT student_id, SUM(score) AS total FROM scores GROUP BY student_id HAVING SUM(score) >= 100;

Alterando e apagando dados

UPDATE scores SET score = score + 5 WHERE student_id = 3 AND subject = 'Matemática';
DELETE FROM scores WHERE score < 50;
SELECT student_id, subject, score FROM scores ORDER BY student_id, subject;

O `UPDATE` aumenta 45 para 50, então o `DELETE` não remove nada. Repare que o resultado está correto para a ordem em que as instruções são executadas.

Resultados reais

name
------
Budi
Siti

name   title
-----  -----
Budi   X-1
Andi   X-2
Siti   X-1

subject      media              n
-----------  -----------------  -
Inglês       65.0               2
Matemática   67.3333333333333   3

student_id  total
----------  -----
1           155
3           105

student_id  subject      score
----------  -----------  -----
1           Inglês       70
1           Matemática   85
2           Matemática   72
3           Inglês       60
3           Matemática   50

Erros comuns

**Esquecer o `WHERE` em `UPDATE` ou `DELETE`:** isso altera ou apaga todas as linhas. Execute antes um `SELECT` com a mesma condição.
**Colocar condição de agregação no `WHERE`:** use `HAVING` para condições sobre totais.
**Usar aspas duplas para valores de texto:** o SQL padrão usa aspas simples `'...'` para texto.
**Esperar `ORDER BY` por padrão:** sem ele, a ordem das linhas não é garantida.

Próximos passos

Modele suas próprias tabelas, por exemplo produtos e pedidos, e escreva um `JOIN` que some as vendas por produto. Depois estude índices e transações, que se tornam importantes quando os dados crescem.

Resumo

O SQL define a estrutura com `CREATE`, gerencia os dados com `INSERT`, `UPDATE` e `DELETE`, e faz consultas com `SELECT` junto com `WHERE`, `JOIN`, `GROUP BY` e `HAVING`. Testar com dados pequenos de exemplo deixa claro o efeito de cada instrução.