SQL NOT

Às vezes é mais fácil dizer o que você não quer. A Ana vai mandar um cartão para todos os clientes da Loja Aurora que moram fora do Piauí. Em vez de listar os outros estados um por um, ela pode pedir "todos, menos os do Piauí". É para isso que serve o NOT ("não", em inglês): ele inverte uma condição do WHERE. O que era verdadeiro vira falso, e o que era falso vira verdadeiro.

Os exemplos usam o banco da Loja Aurora. Cada quadro "Resultado" é desenhado pelo SQLite de verdade, rodando no seu navegador. Se ainda não viu o WHERE, comece por WHERE; o NOT conversa muito com AND e OR, das aulas anteriores.

A ideia: tirar da pilha

Imagine as fichas dos 30 clientes da loja numa pilha em cima da mesa. A Ana pode fazer dois pedidos diferentes ao ajudante:

O ajudante faz a mesma pergunta para cada ficha ("é do Piauí?"), mas, com o NOT, fica com as fichas em que a resposta foi não. O NOT não muda a pergunta; ele troca a resposta.

1. O primeiro NOT

Os clientes que não moram no Piauí:

SELECT nome, cidade, estado
FROM clientes
WHERE NOT estado = 'PI';

WHERE

"Onde": o filtro. Só passam as linhas em que a condição dá verdadeiro.

NOT

"Não": inverte a condição que vem logo depois dele.

estado = 'PI'

A condição original: "o estado é PI?". Para José Ribamar (PI) a resposta é sim; para Ana Beatriz (SP), não.

NOT estado = 'PI'

A condição invertida: para José Ribamar, o "sim" virou "não", e ele fica de fora; para Ana Beatriz, o "não" virou "sim", e ela entra.

Resultado: 16 clientes, de São Paulo, Fortaleza e Recife. Os outros 14 moram no Piauí (Teresina, Parnaíba, Picos, Oeiras, Floriano). 16 + 14 = 30, a tabela inteira: o NOT pegou exatamente o "resto".

2. Verdadeiro e falso no SQLite: 1 e 0

Para entender o NOT de verdade, vale ver o que ele faz com um valor solto. No SQLite, "verdadeiro" é 1 e "falso" é 0. Você pode perguntar direto, sem tabela nenhuma:

SELECT NOT 1, NOT 0, NOT 5, NOT NULL;

Colunas de sim ou não

A Loja Aurora guarda "sim ou não" como 1 ou 0. A coluna vip dos clientes é 1 para os 5 clientes VIP e 0 para os outros. A coluna descontinuado dos produtos é 1 para os produtos que a loja parou de vender. Para ver os produtos que não são "não descontinuados" (ou seja, os descontinuados):

SELECT nome, preco, estoque
FROM produtos
WHERE NOT descontinuado = 0;

Dois produtos, os dois com estoque 0. Esse exemplo é de propósito "torto", para você treinar a leitura: "não é igual a zero" é o mesmo que "é igual a 1". Na vida real, a Ana escreveria WHERE descontinuado = 1, que é mais fácil de ler.

Como 0 já é falso e 1 já é verdadeiro, no SQLite dá até para usar a coluna sozinha. Os clientes que não são VIP:

SELECT nome, vip
FROM clientes
WHERE NOT vip;

25 clientes, todos com vip 0. Para o cliente 2 (Maria Clara), vip é 0, NOT 0 é 1 (verdadeiro), e ela entra. Para o cliente 1 (José Ribamar), vip é 1, NOT 1 é 0, e ele fica de fora. É o mesmo que WHERE NOT vip = 1 ou WHERE vip = 0.

SELECT nome, categoria_id
FROM produtos
WHERE categoria_id = 1;

SELECT nome, categoria_id
FROM produtos
WHERE NOT categoria_id = 1;

3. NOT junto com AND: a ordem importa

A Ana quer os clientes VIP que não são do Piauí. Ela escreve:

SELECT nome, cidade, estado, vip
FROM clientes
WHERE NOT estado = 'PI' AND vip = 1;

Três clientes: Ana Beatriz (SP), Fernanda e Mirela (CE). Deu certo porque o SQL lê as partes nesta ordem:

1. Primeiro as comparações: estado = 'PI' e vip = 1.
2. Depois o NOT, que inverte só a comparação que está colada nele: estado = 'PI'.
3. Depois o AND, que junta as duas partes.
4. Por último, o OR (se houver).

Ou seja, o SQL entendeu (NOT estado = 'PI') AND (vip = 1). Agora veja o que acontece com parênteses em volta das duas condições:

SELECT nome, cidade, estado, vip
FROM clientes
WHERE NOT (estado = 'PI' AND vip = 1);

28 clientes! Agora o NOT inverte a pergunta inteira que está dentro dos parênteses: "é do Piauí e é VIP?". Só dois clientes respondem "sim" a ela (José Ribamar e Larissa, os VIPs do Piauí); com o NOT, saem esses dois e ficam os outros 28. Parece uma diferença pequena na escrita, mas a pergunta mudou completamente.

4. NOT de um OR: a troca de De Morgan

A Ana quer os clientes que nem são do Piauí nem são VIP: os que vão receber um cupom de boas-vindas para conhecer a loja. Dá para escrever de dois jeitos:

SELECT nome, cidade, estado, vip
FROM clientes
WHERE NOT (estado = 'PI' OR vip = 1);

SELECT nome, cidade, estado, vip
FROM clientes
WHERE NOT estado = 'PI' AND NOT vip = 1;

Os dois devolvem os mesmos 13 clientes. Essa troca tem nome: é a lei de De Morgan, de um matemático inglês do século XIX. Ela diz:

Quando o NOT "entra" nos parênteses, ele inverte cada pedaço e troca o OR por AND (ou o AND por OR). O erro clássico é inverter os pedaços e esquecer de trocar o conector.

5. NOT com mais de uma condição negada

A Ana quer os clientes das cidades "pequenas" da lista, as que não são as três maiores (Teresina, São Paulo e Fortaleza):

SELECT nome, cidade
FROM clientes
WHERE NOT cidade = 'Teresina'
  AND NOT cidade = 'São Paulo'
  AND NOT cidade = 'Fortaleza';

Seis clientes, de Parnaíba, Recife, Picos, Oeiras e Floriano. Funciona, mas repare como ficou comprido. Para "não é nenhum destes", o SQL tem um jeito mais curto, o NOT IN, que você vai ver na aula IN:

SELECT nome, cidade
FROM clientes
WHERE cidade NOT IN ('Teresina', 'São Paulo', 'Fortaleza');

O NOT aparece "grudado" em vários outros operadores do SQL. Cada um tem a sua aula; aqui vai só o mapa:

Nos três primeiros, o NOT pode ir antes da coluna também: NOT nome LIKE 'Ana %' e nome NOT LIKE 'Ana %' dão o mesmo resultado (28 clientes, todos menos as duas Anas). A forma com o NOT no meio é a mais comum, porque se lê como português.

6. A armadilha do NULL

A Loja Aurora tem 6 fornecedores. Dois são do Piauí (a Distribuidora Piauí Center e a Norte Suprimentos). A Ana pede os que não são do Piauí, esperando ver os outros quatro:

SELECT nome, estado
FROM fornecedores
WHERE NOT estado = 'PI';

Vieram só dois. Sumiram a Lusitana Comércio (de Portugal) e a Pampa Sur (da Argentina). Elas não são do Piauí, então por que não apareceram? Porque fornecedor estrangeiro não tem estado brasileiro: a coluna estado deles é NULL (vazia, "não sei"). Veja o que o SQLite calcula em cada linha:

SELECT nome, estado, estado = 'PI', NOT estado = 'PI'
FROM fornecedores;

Nas duas últimas linhas da conta, a comparação estado = 'PI' deu NULL: o SQLite não sabe se um valor desconhecido é igual a 'PI'. E, como você viu na seção 2, NOT NULL continua NULL. O WHERE só deixa passar o que é verdadeiro; "não sei" não é verdadeiro, e a linha fica de fora.

O mesmo acontece com os 3 clientes sem email: WHERE NOT email LIKE '%@exemplo.com.br' devolve 0 linhas, e não os 3 clientes que não têm esse email. Linhas com NULL na coluna testada nunca passam por um NOT, nem pela condição sem NOT.

Para incluir os estrangeiros, diga com todas as letras que o NULL também serve:

SELECT nome, estado
FROM fornecedores
WHERE NOT estado = 'PI' OR estado IS NULL;

Agora são os quatro. O IS NULL ("é vazio") é a única pergunta que responde "sim" para um NULL; ele tem aula própria, IS NULL e IS NOT NULL, e o próprio NULL é explicado em O Valor NULL.

SELECT nome, cidade, estado, pais
FROM fornecedores
WHERE NOT estado = 'PI';

SELECT nome, cidade, estado, pais
FROM fornecedores
WHERE NOT estado = 'PI' OR estado IS NULL;

7. Formas diferentes de dizer "não"

Para "o estado não é PI", o SQL aceita várias escritas. Nos clientes, todas dão os mesmos 16:

Todas as quatro têm a mesma armadilha do NULL: nenhuma delas deixa passar os fornecedores estrangeiros.

Quando dá errado

SELECT nome FROM clientes WHERE estado NOT = 'PI';

$ sqlite3 loja.db
SQLite version 3.50.4 2025-07-30 19:33:53
Enter ".help" for usage hints.
sqlite> SELECT nome FROM clientes WHERE estado NOT = 'PI';
Parse error: near "=": syntax error
  SELECT nome FROM clientes WHERE estado NOT = 'PI';
                               error here ---^
sqlite> .quit

SELECT nome FROM clientes WHERE ! vip;

SELECT nome FROM clientes WHERE NOT estado = PI;

-- PostgreSQL, com uma coluna do tipo boolean
SELECT nome FROM clientes WHERE NOT vip;      -- vip é boolean: funciona
SELECT nome FROM clientes WHERE vip = false;  -- o mesmo, por extenso

Referência rápida

Exercícios

Missão final: o cupom de boas-vindas

SELECT nome, cidade, vip
FROM clientes
WHERE cidade = 'Teresina';

SELECT nome, cidade, vip
FROM clientes
WHERE NOT cidade = 'Teresina' AND NOT vip = 1;

Conseguiu? Tente também a forma com parênteses, NOT (cidade = 'Teresina' OR vip = 1), e confira que dá os mesmos 17. Nenhum cliente tem cidade vazia, então aqui a armadilha do NULL não aparece.

Resumo

• NOT ("não") inverte uma condição: o WHERE passa a ficar com as linhas em que ela é falsa.
• No SQLite, verdadeiro é 1 e falso é 0: NOT 1 dá 0, NOT 0 dá 1. Por isso WHERE NOT vip funciona, mas vip = 0 roda em qualquer banco.
• O NOT vem antes da condição: NOT estado = 'PI'. Escrito no meio (estado NOT = 'PI'), dá near "=": syntax error.
• Ordem: comparações, depois NOT, depois AND, depois OR. NOT A AND B inverte só o A; para inverter tudo, use parênteses.
• De Morgan: NOT (A OR B) = NOT A AND NOT B; NOT (A AND B) = NOT A OR NOT B.
• NOT NULL continua NULL: linhas com a coluna vazia ficam de fora tanto da condição quanto do NOT. Para incluí-las, acrescente OR coluna IS NULL.