SQL Academy · Aula

Expressões CASE e consultas de tabela dinâmica

Use CASE WHEN dentro de agregações para transformar tabelas longas em relatórios de tabela cruzada amplos.

Expressões CASE e consultas de tabela dinâmica é uma aula grátis de SQL Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de SQL Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de SQL Academy inclui 4 aulas no total.

CASE: If/Else embutido para SQL

CASE é o operador ternário do SQL. Há duas formas:

-- Searched CASE
CASE WHEN x > 0 THEN 'positive'
     WHEN x < 0 THEN 'negative'
     ELSE 'zero' END

-- Simple CASE
CASE status
  WHEN 'A' THEN 'active'
  WHEN 'P' THEN 'pending'
  ELSE 'unknown'
END

CASE em SELECT

Calcule uma coluna derivada:

SELECT id, total,
       CASE
         WHEN total >= 1000 THEN 'whale'
         WHEN total >=  100 THEN 'regular'
         ELSE 'small'
       END AS bucket
FROM orders;

CASE em WHERE e ORDER BY

Filtragem e ordenação personalizadas:

-- Custom sort:
ORDER BY
  CASE WHEN status = 'urgent' THEN 0 ELSE 1 END,
  created_at DESC;

-- Conditional filter:
WHERE CASE WHEN $1 = 'paid' THEN status = 'paid'
           ELSE status IN ('pending','paid')
      END;

CASE dentro de agregações: contagens condicionais

O truque clássico de PIVOT:

SELECT user_id,
       COUNT(*) AS total,
       SUM(CASE WHEN status = 'paid'      THEN 1 ELSE 0 END) AS paid,
       SUM(CASE WHEN status = 'pending'   THEN 1 ELSE 0 END) AS pending,
       SUM(CASE WHEN status = 'cancelled' THEN 1 ELSE 0 END) AS cancelled
FROM orders
GROUP BY user_id;

FILTER: alternativa mais clara

A cláusula FILTER do PostgreSQL é mais legível:

SELECT user_id,
       COUNT(*)                                     AS total,
       COUNT(*) FILTER (WHERE status = 'paid')      AS paid,
       COUNT(*) FILTER (WHERE status = 'pending')   AS pending,
       COUNT(*) FILTER (WHERE status = 'cancelled') AS cancelled
FROM orders
GROUP BY user_id;

Transformando meses em colunas

Converta do formato longo para o formato largo usando CASE + agregação:

SELECT year,
       SUM(CASE WHEN month =  1 THEN revenue END) AS jan,
       SUM(CASE WHEN month =  2 THEN revenue END) AS feb,
       -- ...
       SUM(CASE WHEN month = 12 THEN revenue END) AS dec
FROM monthly_revenue
GROUP BY year
ORDER BY year;

Transformando categorias

Uma linha por usuário, uma coluna por status:

SELECT user_id,
       SUM(total) FILTER (WHERE status = 'paid')      AS paid_total,
       SUM(total) FILTER (WHERE status = 'pending')   AS pending_total
FROM orders GROUP BY user_id;

Limitações de PIVOT com CASE

Você precisa conhecer as colunas de destino no momento em que escreve a consulta. Para PIVOTs dinâmicos, gere o SQL na aplicação ou use PL/pgSQL procedural.

CASE vs COALESCE / NULLIF

COALESCE = "primeiro valor não NULL". NULLIF = "NULL se forem iguais". CASE é mais geral — use-o quando COALESCE/NULLIF não forem adequados.

Compatibilidade de tipos

Todas as ramificações de CASE devem produzir tipos compatíveis. Faça a conversão de tipo explicitamente ao misturar tipos:

SELECT CASE WHEN x THEN 1::TEXT ELSE 'no' END;

CASE aninhado

Ramificação em vários níveis:

SELECT CASE
  WHEN amount IS NULL THEN 'no payment'
  WHEN amount = 0     THEN 'free'
  WHEN amount < 10    THEN 'cheap'
  ELSE
    CASE WHEN paid_at IS NULL THEN 'overdue' ELSE 'paid' END
END AS status FROM invoices;

Recapitulação

CASE é o "if/else" universal do SQL.

Colunas calculadas em SELECT
PIVOTs usando CASE em agregações ou FILTER
Lógica personalizada em WHERE / ORDER BY

Verificação rápida

Qual cláusula é mais legível para agregação condicional no PostgreSQL?

Perguntas Frequentes

A aula “Expressões CASE e consultas de tabela dinâmica” é grátis?

Sim — o texto completo de “Expressões CASE e consultas de tabela dinâmica” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de SQL Academy, atualize para CoddyKit PRO. O curso de SQL Academy inclui 4 aulas no total.

O que vou aprender em “Expressões CASE e consultas de tabela dinâmica”?

Use CASE WHEN dentro de agregações para transformar tabelas longas em relatórios de tabela cruzada amplos. Você pratica SQL Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar SQL Academy?

Nenhuma experiência prévia é necessária. SQL Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Expressões CASE e consultas de tabela dinâmica”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de SQL Academy?

Sim. Cada aula de SQL Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

UNION, INTERSECT, EXCEPT
UNION ALL em comparação com UNION (custo da remoção de duplicatas)
Expressões CASE e consultas de tabela dinâmica
Padrões de tabela cruzada (crosstab() do PostgreSQL)

← Voltar para SQL Academy