CASE no SQLite: WHEN, THEN, ELSE e IIF

CASE é o If/Else do SQL

O CASE é como você coloca lógica condicional dentro de uma query no SQLite. Ele percorre os ramos WHEN na ordem, escolhe o primeiro que casar e devolve o valor que vem depois do THEN. Se nada casar, retorna o valor do ELSE — ou NULL, caso você não tenha escrito um.

A palavra-chave aqui é expressão. O CASE produz um valor, então ele cabe em qualquer lugar onde um valor é aceito: uma coluna do SELECT, uma chave do ORDER BY, o lado direito de uma comparação ou até como argumento de uma função.

SELECT
    'maçã' AS item,
    CASE
        WHEN 5 > 3 THEN 'sim'
        ELSE 'não'
    END AS bigger;

Esse é o esqueleto: CASE, um ou mais WHEN ... THEN ..., um ELSE opcional e fecha com END. O END é obrigatório — esquecer dele é o erro de digitação mais comum aqui.

Um exemplo prático de CASE WHEN no SQLite

Imagine que você tem uma tabela de pedidos e quer classificar cada linha pelo tamanho. Vamos montar uma rapidinho ali na hora pra você poder rodar a query:

WITH orders(id, total) AS (
    VALUES
        (1, 12.00),
        (2, 89.50),
        (3, 250.00),
        (4, 5.25),
        (5, 1200.00)
)
SELECT
    id,
    total,
    CASE
        WHEN total < 10 THEN 'minúsculo'
        WHEN total < 100 THEN 'pequeno'
        WHEN total < 500 THEN 'médio'
        ELSE 'grande'
    END AS size_bucket
FROM orders;

Os ramos são avaliados de cima para baixo. O primeiro que casar vence, então ordene do mais específico para o mais genérico. O ELSE funciona como uma rede de segurança, capturando tudo o que não bateu — sem ele, 1200.00 voltaria como NULL em vez de 'grande'.

Diferença entre CASE simples e pesquisado no SQLite

O exemplo acima usa a forma pesquisada (searched): cada WHEN carrega sua própria condição booleana. Quando você só precisa comparar uma mesma expressão com vários valores fixos, dá para encurtar usando a forma simples:

WITH users(id, status) AS (
    VALUES
        (1, 'A'),
        (2, 'B'),
        (3, 'C'),
        (4, 'A')
)
SELECT
    id,
    status,
    CASE status
        WHEN 'A' THEN 'ativo'
        WHEN 'B' THEN 'banido'
        WHEN 'C' THEN 'fechado'
        ELSE 'desconhecido'
    END AS status_label
FROM users;

A expressão depois do CASE é avaliada uma vez e comparada com = contra cada valor de WHEN. Fica mais limpo quando você está fazendo comparações de igualdade em uma única coluna.

Tem um detalhe importante: o CASE simples usa =, e NULL = NULL não é verdadeiro em SQL. Se status puder ser NULL, os ramos 'A'/'B'/'C' não vão casar com ele — vai cair no ELSE. Para tratar NULL de forma explícita, mude para a forma pesquisada e use WHEN status IS NULL THEN ....

CASE dentro de ORDER BY no SQLite

O ORDER BY aceita qualquer expressão, então o CASE funciona tranquilamente ali. É útil quando você quer uma ordenação personalizada que não segue ordem alfabética nem numérica:

WITH tickets(id, priority) AS (
    VALUES
        (1, 'low'),
        (2, 'high'),
        (3, 'medium'),
        (4, 'high'),
        (5, 'low')
)
SELECT id, priority
FROM tickets
ORDER BY
    CASE priority
        WHEN 'high' THEN 1
        WHEN 'medium' THEN 2
        WHEN 'low' THEN 3
    END,
    id;

'high' < 'low' < 'medium' na ordem alfabética, o que não serve pra nada quando você precisa priorizar tarefas. Mapeando cada prioridade para um número com CASE, você consegue a ordem que realmente faz sentido. O , id no final serve como critério de desempate estável.

CASE dentro do WHERE no SQLite

Dá pra usar CASE dentro do WHERE, mas, na maioria das vezes, não compensa — encadear AND/OR fica bem mais legível. Onde ele realmente brilha é quando a própria condição depende de outro valor:

WITH produtos(id, nome, preco, em_promocao) AS (
    VALUES
        (1, 'caneca', 12.00, 1),
        (2, 'camisa', 25.00, 0),
        (3, 'boné', 18.00, 1),
        (4, 'bolsa', 45.00, 0)
)
SELECT id, nome, preco
FROM produtos
WHERE preco < CASE WHEN em_promocao = 1 THEN 20 ELSE 30 END;

Itens em promoção entram com preço abaixo de 20; os demais, abaixo de 30. Ou seja, o próprio limite muda conforme a condição. Sem o CASE, você teria que escrever algo como (on_sale = 1 AND price < 20) OR (on_sale = 0 AND price < 30) — dá no mesmo, mas polui a consulta.

CASE dentro de funções de agregação

É aqui que o CASE realmente brilha. Combinando com SUM ou COUNT, dá pra calcular totais de um subconjunto de linhas numa única varredura — é o jeito SQL de dizer "conta quantas atendem a essa condição":

WITH orders(id, total, status) AS (
    VALUES
        (1, 50.00, 'paid'),
        (2, 30.00, 'pending'),
        (3, 75.00, 'paid'),
        (4, 20.00, 'cancelled'),
        (5, 100.00, 'paid')
)
SELECT
    COUNT(*) AS all_orders,
    SUM(CASE WHEN status = 'paid' THEN 1 ELSE 0 END) AS paid_count,
    SUM(CASE WHEN status = 'paid' THEN total ELSE 0 END) AS paid_revenue
FROM orders;

O CASE devolve 1 para as linhas que batem com a condição e 0 para o resto, então o SUM acaba virando uma contagem condicional. Esse mesmo truque funciona para faturamento — basta retornar total nas linhas que se encaixam e 0 nas demais. Uma única varredura na tabela e você já consegue várias agregações condicionais.

IIF: o atalho de duas saídas

Quando você tem uma única condição com apenas dois resultados possíveis, o SQLite oferece o IIF(cond, when_true, when_false). É só um açúcar sintático para CASE WHEN cond THEN when_true ELSE when_false END:

WITH accounts(id, balance) AS (
    VALUES
        (1, 100.00),
        (2, -25.00),
        (3, 0.00),
        (4, 1500.00)
)
SELECT
    id,
    balance,
    IIF(balance < 0, 'saldo negativo', 'ok') AS state
FROM accounts;

Use IIF quando a lógica for binária e fizer mais sentido em uma única linha. Já o CASE entra em cena quando você tem três ou mais ramificações, precisa tratar NULL separadamente ou quer aproveitar a ordem de avaliação das várias cláusulas WHEN.

Armadilhas que vale conhecer

Algumas coisas costumam pegar a galera de surpresa:

• Esquecer o END. O CASE abre um bloco e o END fecha. O SQLite só vai acusar o erro de parsing bem depois do ponto onde você realmente errou.
• Sem ELSE, o resultado é NULL. Se nenhuma das ramificações WHEN casar e você não colocou ELSE, sobra NULL. Às vezes é isso que você quer mesmo, mas na maioria das vezes não é.
• A ordem das ramificações importa. Na forma pesquisada, o primeiro WHEN que bater vence. Colocar WHEN total < 500 antes de WHEN total < 100 faz a segunda condição nunca ser alcançada.
• Mistura de tipos. Cada ramificação pode devolver um tipo diferente e o SQLite não vai reclamar — mas o código que consome o resultado pode reclamar. Procure manter tipos compatíveis em todos os ramos (tudo texto, tudo numérico).
• CASE simples e NULL. Como já comentamos: a forma simples usa =, que nunca casa com NULL. Quando tiver nulos em jogo, vá de forma pesquisada.

A seguir: funções de string

O CASE permite ramificar a partir de valores; o próximo capítulo começa a parte de transformar valores. As funções de string — UPPER, LOWER, SUBSTR, REPLACE e os padrões com LIKE — cuidam do trabalho do dia a dia de limpar e reformatar colunas de texto. É o que vem na sequência.