Como o SQL que a Lina Pediu à IA Dobrou as Vendas do Mês Passado - O Hábito de Conferir pelo Número de Linhas

2026-10-24 Tempo de leitura: Cerca de 10 min Dificuldade: Introdução

Você pediu um SQL para a IA. Ele rodou sem erros, mas os números não batem. Já aconteceu com você? Neste artigo, o Veterano Linny e a Lina constroem um hábito: conferir com os próprios olhos o número de linhas e uma linha do resultado.

O que você vai aprender

• Por que um SQL que roda sem erros ainda pode responder a outra pergunta
• Como perceber um JOIN que aumentou as linhas, e duas formas de corrigir
• O hábito de contar com a mesma condição antes de um UPDATE, e uma conferência de 3 passos para respostas da IA

Introdução

Conclusão: Rodar sem erros e dar a resposta certa são coisas diferentes. Se as vendas parecem em dobro, conte as linhas primeiro.

1. O que Aconteceu? A Lina Rodou o SQL da IA do Jeito que Veio

Conclusão: O SQL que junta três tabelas devolveu 18 linhas em vez de uma linha por membro. Por isso o total cresceu.

Os dados de treino da academia da Lina, gym.db, têm três tabelas.

sqlite3 gym.db <<'EOF'
DROP TABLE IF EXISTS members;
DROP TABLE IF EXISTS enrollments;
DROP TABLE IF EXISTS payments;
CREATE TABLE members (id INTEGER PRIMARY KEY, name TEXT, city TEXT);
INSERT INTO members VALUES
  (1,'Pip','Tokyo'), (2,'Momo','Tokyo'), (3,'Kai','Sapporo'),
  (4,'Luna','Tokyo'), (5,'Nico','Tokyo'), (6,'Rio','Osaka'),
  (7,'Sora','Osaka'), (8,'Tama','Osaka'), (9,'Ana','Lisboa'),
  (10,'Ken','Porto'), (11,'Yuki','Lisboa'), (12,'Leo','Austin');
CREATE TABLE enrollments (member_id INTEGER, plan TEXT, ended_at TEXT);
INSERT INTO enrollments VALUES
  (1,'student','2025-03-31'), (1,'basic','2026-03-31'), (1,'pro',NULL),
  (2,'basic',NULL),
  (3,'basic','2025-08-31'), (3,'student','2026-01-31'), (3,'pro',NULL),
  (4,'student',NULL),
  (5,'pro','2025-06-30'), (5,'basic','2026-02-28'), (5,'pro',NULL),
  (6,'basic',NULL),
  (7,'basic','2025-09-30'), (7,'pro','2026-04-30'), (7,'pro',NULL),
  (9,'basic',NULL), (10,'student',NULL), (11,'basic',NULL);
CREATE TABLE payments (member_id INTEGER, amount INTEGER);
INSERT INTO payments VALUES
  (1,4500), (2,3000), (3,4500), (4,2000), (5,4500),
  (6,3000), (7,4500), (9,3000), (10,2000), (11,3000);
EOF

$ sqlite3 gym.db "SELECT m.name, e.plan, p.amount
FROM members m
JOIN enrollments e ON e.member_id = m.id
JOIN payments p ON p.member_id = m.id;"

Pip|student|4500
Pip|basic|4500
Pip|pro|4500
Momo|basic|3000
Kai|basic|4500
Kai|student|4500
Kai|pro|4500
Luna|student|2000
Nico|pro|4500
Nico|basic|4500
Nico|pro|4500
Rio|basic|3000
Sora|basic|4500
Sora|pro|4500
Sora|pro|4500
Ana|basic|3000
Ken|student|2000
Yuki|basic|3000

$ sqlite3 gym.db "SELECT SUM(p.amount)
FROM members m
JOIN enrollments e ON e.member_id = m.id
JOIN payments p ON p.member_id = m.id;"

70000

$ sqlite3 gym.db "SELECT SUM(amount) FROM payments;"

34000

2. Conte Primeiro: 12 Membros, 18 Linhas

Conclusão: Uma lista com uma linha por membro nunca deveria ter mais linhas do que membros. 18 linhas para 12 pessoas mostram linhas a mais.

$ sqlite3 gym.db "SELECT COUNT(*) FROM members;"

12

$ sqlite3 gym.db "SELECT COUNT(*)
FROM members m
JOIN enrollments e ON e.member_id = m.id
JOIN payments p ON p.member_id = m.id;"

18

$ sqlite3 gym.db "SELECT * FROM enrollments WHERE member_id = 1;"

1|student|2025-03-31
1|basic|2026-03-31
1|pro|

Uma relação em que "uma pessoa tem vários registros" se chama um para muitos. Quando você faz JOIN com uma tabela um para muitos, o resultado ganha tantas linhas quanto o lado "muitos" tiver.

3. Duas Correções: Manter Só as Linhas Atuais / Somar Antes

Conclusão: Mantenha só as linhas do plano atual, ou some por membro antes de juntar. Os dois jeitos dão 10 linhas e 34.000 ienes.

Correção 1: manter só as linhas do plano atual

$ sqlite3 gym.db "SELECT COUNT(*) FROM enrollments WHERE ended_at = NULL;"

0

$ sqlite3 gym.db "SELECT COUNT(*) FROM enrollments WHERE ended_at IS NULL;"

10

$ sqlite3 gym.db "SELECT m.name, e.plan, p.amount
FROM members m
JOIN enrollments e ON e.member_id = m.id
JOIN payments p ON p.member_id = m.id
WHERE e.ended_at IS NULL;"

Pip|pro|4500
Momo|basic|3000
Kai|pro|4500
Luna|student|2000
Nico|pro|4500
Rio|basic|3000
Sora|pro|4500
Ana|basic|3000
Ken|student|2000
Yuki|basic|3000

Correção 2: somar antes, depois juntar

$ sqlite3 gym.db "SELECT m.name, t.total
FROM members m
JOIN (SELECT member_id, SUM(amount) AS total
      FROM payments GROUP BY member_id) t
  ON t.member_id = m.id;"

Pip|4500
Momo|3000
Kai|4500
Luna|2000
Nico|4500
Rio|3000
Sora|4500
Ana|3000
Ken|2000
Yuki|3000

4. Conte Antes de Mudar: um UPDATE sem WHERE

Conclusão: Antes de rodar o UPDATE, rode COUNT(*) com o mesmo WHERE. Se só uma linha deve mudar, confirme que aparece 1 antes de rodar.

UPDATE members
SET city = 'Osaka'
WHERE id = 3;

$ cp gym.db gym-backup.db

$ sqlite3 gym.db "UPDATE members SET city = 'Osaka'; SELECT changes();"

12

$ sqlite3 gym.db "SELECT city, COUNT(*) FROM members GROUP BY city;"

Osaka|12

$ cp -i gym-backup.db gym.db

cp: overwrite 'gym.db'? y

$ sqlite3 gym.db "SELECT COUNT(*) FROM members WHERE id = 3;"

1

$ sqlite3 gym.db "SELECT * FROM members WHERE id = 3;"

3|Kai|Sapporo

$ sqlite3 gym.db "UPDATE members SET city = 'Osaka' WHERE id = 3; SELECT changes();"

1

5. Uma Conferência de 3 Passos ao Pedir para a IA

Conclusão: Preveja o número de linhas, conte com COUNT(*) e olhe uma linha. Esses 3 passos pegam resultados com linhas demais e de menos.

$ sqlite3 gym.db "SELECT COUNT(*) FROM members WHERE city = 'Tokyo';"

4

$ sqlite3 gym.db "SELECT name FROM members WHERE city = 'Tokyo';"

Pip
Momo
Luna
Nico

$ sqlite3 gym.db "SELECT 'Sao Paulo' = 'São Paulo', 'São Paulo' = 'São Paulo';"

0|1

Aqui estão os tropeços mais comuns numa tabela.

Mini Exercícios

Conclusão: Teste a conferência de 3 passos no gym.db de treino. Conte, olhe uma linha e decida você mesmo se está certo.

Exercício 1: quantos membros estão no plano pro agora?

Tarefa: Você pediu para a IA "o número de membros que estão no plano pro agora", e ela devolveu SELECT COUNT(*) FROM enrollments WHERE plan = 'pro';. O resultado é 6. Confira se está certo.

$ sqlite3 gym.db "SELECT member_id, plan, ended_at FROM enrollments WHERE plan = 'pro';"

1|pro|
3|pro|
5|pro|2025-06-30
5|pro|
7|pro|2026-04-30
7|pro|

$ sqlite3 gym.db "SELECT COUNT(*) FROM enrollments WHERE plan = 'pro' AND ended_at IS NULL;"

4

Exercício 2: conte antes de mudar

Tarefa: A Luna se mudou para Osaka. Antes de mudar a cidade dela para Osaka, confirme que só uma linha vai mudar, e depois rode.

$ cp gym.db gym-backup.db

$ sqlite3 gym.db "SELECT COUNT(*) FROM members WHERE name = 'Luna';"

1

$ sqlite3 gym.db "SELECT * FROM members WHERE name = 'Luna';"

4|Luna|Tokyo

$ sqlite3 gym.db "UPDATE members SET city = 'Osaka' WHERE name = 'Luna'; SELECT changes();"

1

Revisão

Conclusão: Não fique desconfiando do SQL da IA. Olhe o número de linhas e uma linha para decidir se está certo. Se estiver, use com segurança.

Resumo em 3 Linhas

Conclusão: Um JOIN que aumenta linhas, um UPDATE que esquece o WHERE e grafias diferentes. Todos aparecem quando você conta as linhas.

1. Desconfie quando houver mais linhas do que membros - juntar uma tabela um para muitos aumenta as linhas e infla o total
2. Conte antes de mudar - antes do UPDATE, rode COUNT(*) com o mesmo WHERE
3. Prever, contar, olhar uma linha - confira o SQL da IA com esses 3 passos