A maioria dos relatórios precisa de alguma lógica: rotular os pedidos como grandes ou pequenos, contar os pedidos pagos e pendentes lado a lado ou mostrar os itens urgentes primeiro. SQL CASE WHEN lida com tudo isso diretamente dentro de uma consulta e funciona em todos os principais bancos de dados.

Executamos todas as consultas aqui no SQLite 3.50 e os resultados mostrados vêm dessa execução. CASE faz parte do SQL padrão, portanto se comporta da mesma maneira no PostgreSQL, MySQL, SQL Server e Oracle para estes exemplos.

O que é CASO QUANDO?

CASE é uma expressão, não um comando separado. Ele avalia as condições em ordem e retorna um valor, para que possa ir a qualquer lugar onde um valor seja permitido: em SELECT, WHERE, GROUP BY, ORDER BY ou dentro de funções. Sempre termina com END.

CASE
  WHEN condition1 THEN result1
  WHEN condition2 THEN result2
  ELSE fallback
END

A tabela de amostra

CREATE TABLE orders (id INT, customer TEXT, total INT, status TEXT);

INSERT INTO orders VALUES
 (1,'Asha',1200,'paid'), (2,'Ben',300,'pending'),
 (3,'Asha',800,'paid'), (4,'Chitra',2500,'shipped'),
 (5,'Dev',150,'cancelled'), (6,'Ben',NULL,'pending');

Observe que o pedido 6 não tem total. Essa linha importa mais tarde.

CASO pesquisado

Esta é a forma mais flexível, já que cada WHEN tem uma condição completa própria:

SELECT id, total,
       CASE
         WHEN total >= 1000 THEN 'large'
         WHEN total >= 500 THEN 'medium'
         ELSE 'small'
       END AS size
FROM orders;

-- 1 | 1200 | large
-- 2 |  300 | small
-- 3 |  800 | medium
-- 4 | 2500 | large
-- 5 |  150 | small
-- 6 | NULL | small

Olhe para a última linha. O pedido 6 não tem total, mas é rotulado como “pequeno”. Ambas as comparações com NULL não eram verdadeiras, então caiu para ELSE. Mostramos como corrigir isso na seção NULL. Sempre dê um nome ao resultado usando AS, ou você pode obter um nome de coluna estranho.

CASO Simples

Ao comparar uma coluna com valores fixos, a forma mais curta é melhor:

SELECT id,
       CASE status
         WHEN 'paid' THEN 'Complete'
         WHEN 'shipped' THEN 'Complete'
         WHEN 'pending' THEN 'Waiting'
       END AS label
FROM orders;

-- 1 | Complete
-- 2 | Waiting
-- 3 | Complete
-- 4 | Complete
-- 5 | NULL
-- 6 | Waiting

O pedido é importante

CASE para na primeira condição verdadeira e este é o bug lógico mais comum. Troque as duas condições da nossa consulta anterior:

SELECT id, total,
       CASE
         WHEN total >= 500 THEN 'medium'
         WHEN total >= 1000 THEN 'large'
         ELSE 'small'
       END AS size
FROM orders WHERE id IN (1, 4);

-- 1 | 1200 | medium
-- 4 | 2500 | medium

Agora nada pode ser “grande”. Um total de 2.500 também é pelo menos 500, então o primeiro ramo vence e o segundo nunca é alcançado. Nenhum erro aparece, apenas rótulos errados. Para intervalos, coloque primeiro a condição mais restritiva ou escreva intervalos completos, como total >= 500 AND total < 1000.

O que acontece sem MAIS?

Em nosso exemplo CASE simples acima, o pedido 5 foi cancelado e nenhuma filial tratou disso, então o resultado foi NULL. Às vezes é exatamente isso que você deseja, como mostra a próxima seção. Mas ao criar rótulos, um ELSE 'other' claro geralmente é melhor, pois torna visíveis valores inesperados em vez de deixar espaços em branco em um relatório.

Relatórios de estilo dinâmico com SUM

Este é um dos padrões mais úteis no SQL diário. Agrupar CASE em um agregado transforma linhas em colunas, com uma linha por cliente:

SELECT customer,
       SUM(CASE WHEN status = 'paid' THEN total ELSE 0 END) AS paid,
       SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) AS pending_orders
FROM orders
GROUP BY customer
ORDER BY customer;

-- Asha   | 2000 | 0
-- Ben    |    0 | 2
-- Chitra |    0 | 0
-- Dev    |    0 | 0

Uma consulta agora fornece a receita paga e o número de pedidos pendentes, sem necessidade de consultas ou junções separadas. O padrão funciona em quase todos os bancos de dados, ao contrário da sintaxe dedicada PIVOT que apenas alguns oferecem. Se GROUP BY for novo para você, leia SQL GROUP BY e HAVING.

Contagens condicionais

COUNT ignora NULLs, então um CASE sem ELSE conta apenas as linhas que correspondem:

SELECT COUNT(*) AS all_orders,
       COUNT(CASE WHEN status = 'paid' THEN 1 END) AS paid_orders,
       COUNT(CASE WHEN total >= 1000 THEN 1 END) AS large_orders
FROM orders;

-- 6 | 2 | 2

Tenha cuidado: se você adicionar ELSE 0 dentro de COUNT, todas as linhas serão contadas, porque 0 não é NULL. Use ELSE 0 com SUM e deixe de fora com COUNT. PostgreSQL e SQLite também suportam COUNT(*) FILTER (WHERE ...), que é bem lido, mas não está disponível em todos os lugares.

Agrupando por um CASE

Você pode criar seus próprios intervalos e resumi-los:

SELECT CASE WHEN total >= 1000 THEN 'large' ELSE 'other' END AS bucket,
       COUNT(*)
FROM orders
GROUP BY bucket
ORDER BY bucket;

-- large | 2
-- other | 4

O agrupamento pelo alias funciona em SQLite, PostgreSQL e MySQL. O SQL Server não permite isso, então você teria que repetir a expressão inteira ou colocar a consulta em uma CTE ou subconsulta primeiro.

Classificação personalizada com ORDER BY

A ordem alfabética raramente é o que uma empresa deseja. CASE permite definir seu próprio pedido:

SELECT id, status FROM orders
ORDER BY CASE status
           WHEN 'pending' THEN 1
           WHEN 'paid' THEN 2
           ELSE 3
         END, id;

-- 2 | pending
-- 6 | pending
-- 1 | paid
-- 3 | paid
-- 4 | shipped
-- 5 | cancelled

Os pedidos pendentes vêm primeiro, o que é útil para uma fila de trabalho. A segunda coluna de classificação, id, mantém as linhas em uma ordem previsível dentro de cada grupo.

CASO em ATUALIZAÇÃO

CASE permite que uma instrução aplique alterações diferentes em linhas diferentes. Aqui, pequenos pedidos pendentes são sinalizados para revisão:

UPDATE orders
SET status = CASE
               WHEN status = 'pending' AND total < 500 THEN 'review'
               ELSE status
             END;

SELECT id, status FROM orders WHERE customer = 'Ben';

-- 2 | review
-- 6 | pending

O ELSE status mantém as outras linhas inalteradas. Deixá-lo de fora é perigoso, porque linhas sem correspondência seriam definidas como NULL. Sem uma cláusula WHERE, esta instrução também afeta todas as linhas, portanto, em tabelas grandes, adicione um filtro e considere agrupar a alteração em uma transação para que você possa verificar o resultado antes de confirmar. Observe também que a ordem 6 não mudou, porque seu total NULL não satisfez total < 500.

Armadilhas NULAS

NULL causa dois problemas distintos com CASE. Primeiro, a forma simples compara usando igualdade, e nada é igual a NULL, nem mesmo o próprio NULL:

SELECT CASE NULL WHEN NULL THEN 'matched' ELSE 'not matched' END;

-- not matched

Então CASE col WHEN NULL nunca corresponde. Use o formulário pesquisado com IS NULL. Em segundo lugar, como vimos na ordem 6, um valor NULL escapa das comparações e chega a ELSE. A solução é verificar primeiro:

SELECT id,
       CASE
         WHEN total IS NULL THEN 'unknown'
         WHEN total >= 1000 THEN 'large'
         ELSE 'other'
       END AS size
FROM orders WHERE id IN (1, 2, 6);

-- 1 | large
-- 2 | other
-- 6 | unknown

O pedido 6 agora recebe um rótulo honesto. Nosso guia sobre valores SQL NULL aborda esse comportamento na íntegra.

CASE versus outras opções

Essa última opção merece uma reflexão. Se um CASE crescer para trinta ramificações e aparecer em cinco consultas, mova o mapeamento para uma tabela e junte-se a ela. Então, uma alteração é uma atualização de linha única, em vez de uma alteração de código em cinco locais.

Erros comuns

• Ordem de condição errada. Uma condição ampla primeiro oculta as mais restritas.
• Esquecimento END. Este é o erro de sintaxe mais frequente.
• Usando WHEN NULL. Nunca corresponde, então use WHEN col IS NULL.
• Adicionando ELSE 0 dentro de COUNT. Conta todas as linhas.
• Omitindo ELSE em um UPDATE. Ele pode limpar valores com NULL.
• Filtragem por CASE em WHERE. Pode impedir que um índice seja usado. Consulte nosso guia sobre otimização de consultas SQL.

Considerações finais

CASE WHEN é um pequeno recurso que faz muito trabalho. Lembre-se de três regras: a primeira ramificação verdadeira vence, as linhas sem correspondência tornam-se NULL sem ELSE e NULL precisa de sua própria verificação. Para praticar, pegue um relatório que você está construindo atualmente com diversas consultas e tente produzi-lo como uma consulta usando SUM(CASE ...).

Perguntas frequentes

Continue aprendendo