SQL: tabelas, relações e transações

Criar tabelas com regras, alterar dados com segurança, relacionar tabelas com chaves e JOIN, e proteger mudanças com transações.

Cerca de 16 min · Revisado em

Ao final, você vai conseguir

  • Criar tabelas com PRIMARY KEY, NOT NULL, UNIQUE e FOREIGN KEY
  • Inserir, alterar e apagar linhas sem atingir dados por engano
  • Juntar tabelas com INNER JOIN e LEFT JOIN e explicar a diferença
  • Explicar quando um índice ajuda e conferir o plano de uma consulta
  • Agrupar mudanças numa transação com BEGIN, COMMIT e ROLLBACK

Na aula anterior você fez perguntas a uma tabela que já existia. Agora você passa para o outro lado: decidir como os dados são guardados. Uma tabela mal desenhada deixa entrar um pedido sem cliente, um e-mail repetido ou um Pix que sai de uma conta e não chega na outra. As regras que você aprende aqui são as que protegem o dinheiro e os dados de quem usa o sistema, e são assunto certo em entrevista de backend e de dados.

Criar uma tabela com regras

Um CREATE TABLE com as regras mais usadas

CREATE TABLE produtos (
  id INTEGER PRIMARY KEY,
  nome TEXT NOT NULL,
  preco REAL NOT NULL CHECK (preco > 0),
  codigo TEXT UNIQUE,
  estoque INTEGER NOT NULL DEFAULT 0
);
  • Chave primária: A PRIMARY KEY identifica cada linha de forma única, como o número de protocolo. Nunca se repete e nunca é nula. No SQLite, INTEGER PRIMARY KEY é preenchida sozinha com o próximo número.
  • NOT NULL: Campo obrigatório. Uma tentativa de gravar um produto sem nome é recusada com erro.
  • Tipo e CHECK: O tipo diz que tipo de valor a coluna guarda. O CHECK acrescenta uma regra de negócio: preço precisa ser positivo.
  • UNIQUE: Não aceita dois produtos com o mesmo código de barras. Diferente da chave primária, uma coluna UNIQUE pode ficar vazia (NULL).
  • DEFAULT: Se ninguém informar o estoque, o banco grava 0.
Tipos de coluna mais comuns
Para guardarSQLitePostgreSQL
números inteirosINTEGERINTEGER, BIGINT
dinheiroREAL ou centavos em INTEGERNUMERIC(10, 2)
textosTEXTTEXT, VARCHAR(100)
datasTEXT no formato 2026-10-14DATE, TIMESTAMP
sim ou nãoINTEGER com 0 ou 1BOOLEAN
id automáticoINTEGER PRIMARY KEYGENERATED ALWAYS AS IDENTITY ou SERIAL

A tabela de produtos

Complete o CREATE TABLE: nome e preco devem ser obrigatórios, e codigo não pode se repetir entre produtos.

CREATE TABLE produtos (
  id INTEGER PRIMARY KEY,
  nome TEXT,
  preco REAL,
  codigo TEXT
);
  • A tabela produtos tem as colunas id, nome, preco e codigo
  • id é a chave primária
  • nome e preco são obrigatórios (NOT NULL)
  • Dois produtos com o mesmo código são recusados (UNIQUE)

Inserir, alterar e apagar linhas

Três comandos mudam os dados: INSERT acrescenta linhas, UPDATE altera valores de linhas que já existem e DELETE apaga linhas. Junto com o SELECT, formam o famoso CRUD: criar, ler, atualizar e apagar.

Os três comandos de escrita

INSERT INTO produtos (nome, preco, estoque)
VALUES ('Sonho', 4.5, 20);

UPDATE produtos
SET estoque = estoque - 1
WHERE nome = 'Sonho';

DELETE FROM produtos
WHERE estoque = 0;

Produto novo na vitrine

Cadastre o produto Pão de queijo, com preço 1.5 e estoque 80. A consulta inicial esquece o estoque: veja o que o banco grava quando falta um valor.

INSERT INTO produtos (nome, preco)
VALUES ('Pão de queijo', 1.5);

SELECT * FROM produtos;
  • O Pão de queijo existe com preço 1.5 e estoque 80
  • Os quatro produtos antigos continuam lá

O reajuste que saiu do controle

O café subiu para 21.9 e o bolo de milho saiu do cardápio. A consulta inicial tem o erro mais perigoso do SQL: rode, veja o estrago, e corrija para mudar só o café. Depois, apague o Bolo de milho.

UPDATE produtos SET preco = 21.9;

SELECT * FROM produtos;
  • O café custa 21.9
  • O pão e o leite mantêm os preços antigos
  • O bolo de milho foi apagado e sobraram 3 produtos

Uma pessoa precisa desativar o cliente de id 42 e roda UPDATE clientes SET ativo = 0;. O banco responde “15.320 linhas alteradas”. O que aconteceu?

  • Faltou o WHERE id = 42, então todos os clientes foram desativados
  • O banco desativou só o cliente 42 e contou as linhas que leu
  • Nada, porque o banco pede confirmação antes de alterar várias linhas

Relacionar tabelas com chaves estrangeiras

Imagine guardar pedidos numa tabela só, repetindo nome, e-mail e telefone da cliente em cada pedido. Se a Ana trocar de e-mail, você precisa alterar 30 linhas, e se esquecer uma, o sistema passa a ter duas Anas. Separar os dados em tabelas que se apontam resolve isso. Essa organização tem nome: normalização.

Da planilha repetida para duas tabelas

Tudo junto (repetido)

pedido | cliente   | email           | valor
10     | Ana Souza | ana@exemplo.com | 120.00
11     | Ana Souza | ana@exemplo.com |  80.00
12     | Bruno     | bruno@exemplo...|  45.00

Normalizado

clientes                         pedidos
id | nome      | email           id | cliente_id | valor
1  | Ana Souza | ana@exemplo.com 10 | 1          | 120.00
2  | Bruno     | bruno@exemplo   11 | 1          |  80.00
                                 12 | 2          |  45.00

Pedidos que apontam para clientes

A tabela clientes já existe. Crie pedidos de forma que cliente_id seja obrigatório e uma chave estrangeira para clientes (id), usando REFERENCES.

CREATE TABLE pedidos (
  id INTEGER PRIMARY KEY,
  cliente_id INTEGER,
  valor REAL NOT NULL,
  data TEXT NOT NULL
);
  • cliente_id é uma chave estrangeira para clientes
  • cliente_id é obrigatório
  • Um pedido de cliente inexistente é recusado

Num sistema de delivery, cada informação deve ficar na tabela de clientes ou na tabela de pedidos?

clientes · pedidos

  • E-mail
  • Data de nascimento
  • Valor total
  • Data e hora da compra
  • Telefone
  • Status da entrega

Juntar tabelas com JOIN

Separar em tabelas evita repetição, mas a pergunta “quem fez cada pedido?” precisa dos dois lados. O JOIN junta as tabelas na hora da consulta, casando as linhas pela condição do ON, normalmente a chave estrangeira com a chave primária.

Como o banco monta cada linha de um INNER JOIN

  1. pedidos → clientes: pedido 10: cliente_id 1. O banco pega um pedido e procura em clientes a linha cujo id é igual ao cliente_id dele.
  2. clientes → Resultado: Ana Souza + 120.00. Achou: a cliente 1 é a Ana. As colunas das duas linhas viram uma linha só no resultado.
  3. pedidos → clientes: pedido 13: cliente_id 4. Mesmo processo para cada pedido. A cliente 4 é o Davi.
  4. clientes → Resultado: Davi Melo + 60.00. Mais uma linha no resultado.
  5. clientes → clientes: Carla: nenhum pedido. A Carla não aparece em nenhum cliente_id. No INNER JOIN, quem não tem par fica de fora. No LEFT JOIN, ela entraria com as colunas de pedido em NULL.

INNER JOIN

Só as linhas que têm par nas duas tabelas. A Carla, sem pedidos, fica de fora.

SELECT c.nome, p.id AS pedido, p.valor
FROM clientes c
INNER JOIN pedidos p ON p.cliente_id = c.id;
nome       | pedido | valor
Ana Souza  |     10 |   120
Ana Souza  |     11 |    80
Bruno Lima |     12 |    45
Davi Melo  |     13 |    60

LEFT JOIN

Todas as linhas da tabela da esquerda (a do FROM), com par ou não. Sem par, as colunas da direita vêm NULL.

SELECT c.nome, p.id AS pedido, p.valor
FROM clientes c
LEFT JOIN pedidos p ON p.cliente_id = c.id;
nome       | pedido | valor
Ana Souza  |     10 |   120
Ana Souza  |     11 |    80
Bruno Lima |     12 |    45
Carla Dias |   NULL |  NULL
Davi Melo  |     13 |    60

Quem fez cada pedido?

A consulta mostra só o número do cliente. Junte com clientes para mostrar o id do pedido, o nome do cliente e o valor. Dica: c.nome quer dizer “a coluna nome da tabela apelidada de c”.

SELECT id, cliente_id, valor
FROM pedidos;
  • Mostra os 4 pedidos
  • Mostra o nome dos clientes

Pedidos por cliente, inclusive zero

O time de marketing quer todos os clientes com a quantidade de pedidos de cada um, para mandar um cupom a quem nunca comprou. A consulta inicial esquece a Carla. Troque o tipo de JOIN e confira se a Carla aparece com 0.

SELECT c.nome, COUNT(*) AS pedidos
FROM clientes c
INNER JOIN pedidos p ON p.cliente_id = c.id
GROUP BY c.id, c.nome;
  • Mostra os 4 clientes
  • Carla Dias aparece com 0 pedidos
  • Ana Souza aparece com 2 pedidos

Índices para buscar rápido, transações para não perder dinheiro

Índices aceleram leituras, mas custam espaço e deixam cada INSERT e UPDATE um pouco mais lento, porque o índice também precisa ser atualizado. Crie índices para colunas muito usadas em WHERE e JOIN, como chaves estrangeiras. Para ver se o banco usa um índice, peça o plano da consulta: EXPLAIN QUERY PLAN no SQLite, EXPLAIN no PostgreSQL.

Do scan ao índice

Rode e leia a coluna detail: SCAN pedidos quer dizer que o banco leu tudo. Antes do EXPLAIN, crie um índice na coluna cliente_id com CREATE INDEX nome_do_indice ON pedidos (cliente_id); e rode de novo.

EXPLAIN QUERY PLAN
SELECT * FROM pedidos WHERE cliente_id = 2;
  • Existe um índice na coluna cliente_id
  • O plano mostra a busca usando o índice

Agora pense num Pix de R$ 50 da Ana para o Bruno. São dois comandos: tirar da Ana e pôr no Bruno. Se o sistema cair entre os dois, o dinheiro some. Uma transação agrupa comandos para que todos aconteçam ou nenhum aconteça: BEGIN abre, COMMIT confirma tudo, ROLLBACK desfaz tudo desde o BEGIN.

Uma transferência dentro de uma transação

  1. Aplicação → Banco de dados: BEGIN. Daqui em diante, nada é definitivo.
  2. Aplicação → Banco de dados: UPDATE saldo da Ana - 50. Outras conexões ainda veem o saldo antigo da Ana.
  3. Aplicação → Banco de dados: UPDATE saldo do Bruno + 50. As duas mudanças estão preparadas, mas não confirmadas.
  4. Aplicação → Banco de dados: COMMIT. As duas mudanças passam a valer juntas. Se algo tivesse falhado antes, um ROLLBACK desfaria tudo.

Um Pix que não some no caminho

A consulta inicial só tira o dinheiro da Ana. Faça a transferência completa de 50 da Ana para o Bruno, dentro de uma transação com BEGIN; e COMMIT;.

UPDATE contas SET saldo = saldo - 50 WHERE titular = 'Ana';

SELECT * FROM contas;
  • Ana fica com 100 e Bruno com 130
  • O total de dinheiro continua 230
  • Usa BEGIN e COMMIT
A Ana tem R$ 100 e tenta mandar R$ 300. A tabela tem CHECK (saldo >= 0). Dentro de uma transação, o primeiro UPDATE falha. O que a aplicação deve fazer, e por que a regra no banco ajuda?

Mandar ROLLBACK, desfazendo qualquer coisa feita desde o BEGIN, e avisar a pessoa que o saldo é insuficiente. O CHECK garante que, mesmo se a aplicação tiver um bug e esquecer de conferir o saldo, o banco recusa deixar a conta negativa.

Uma consulta que busca pedidos por cliente_id ficou lenta depois que a tabela passou de 5 milhões de linhas. O que você investiga primeiro?

  • O plano da consulta, para ver se há um índice em cliente_id ou se o banco faz scan
  • Criar índices em todas as colunas da tabela, por garantia
  • Trocar o banco por outro mais rápido

Fechamento

  • CREATE TABLE define colunas, tipos e regras: PRIMARY KEY identifica cada linha, NOT NULL torna obrigatório, UNIQUE proíbe repetidos e CHECK valida regras de negócio.
  • INSERT, UPDATE e DELETE mudam os dados; UPDATE e DELETE sem WHERE atingem a tabela inteira.
  • Normalizar é guardar cada informação num lugar só; uma FOREIGN KEY liga as tabelas e impede referências a registros que não existem.
  • INNER JOIN traz só as linhas com par nas duas tabelas; LEFT JOIN mantém todas as da esquerda, com NULL onde não há par.
  • Índices aceleram buscas ao custo de escritas mais lentas; transações com BEGIN, COMMIT e ROLLBACK garantem que um grupo de mudanças acontece por inteiro ou não acontece.

Modele usuários e pedidos no PostgreSQL

Monte um banco pequeno de verdade, com as regras desta aula, e prove que elas funcionam tentando quebrá-las.

  1. Instale o PostgreSQL (ou rode com Docker) e crie as tabelas clientes e pedidos com chave primária, NOT NULL, UNIQUE no e-mail e chave estrangeira em cliente_id, usando NUMERIC(10, 2) para valores
  2. Insira dados e tente gravar um e-mail repetido e um pedido de cliente inexistente; anote as mensagens de erro
  3. Escreva uma consulta com LEFT JOIN que mostre cada cliente com a quantidade e o total de pedidos, e confira à mão para dois clientes
  4. Execute uma transação com BEGIN, faça um UPDATE errado de propósito, rode ROLLBACK e verifique que nada mudou
  5. Compare o EXPLAIN de uma busca por cliente_id antes e depois de criar um índice (com poucas linhas, o PostgreSQL pode preferir o scan; insira alguns milhares com generate_series)

Referências

Cursos relacionados