Área Didática9 min de leitura

SQL Intermediário (Aula 6): Lógica Condicional com CASE WHEN e Subqueries Avançadas

Crie colunas dinâmicas com CASE WHEN para categorizar registros em tempo real e aprenda a aninhar consultas com Subqueries no SELECT, FROM e WHERE.

TK
Thalisson
Publicado em:
#SQL#SQL Intermediário#Área Didática#Banco de Dados#CASE WHEN#Subqueries#Consultas Aninhadas
SQL Intermediário (Aula 6): Lógica Condicional com CASE WHEN e Subqueries Avançadas
ℹ️
Transparência Editorial: O blog TK.Soft é financiado por leitores. Quando você compra através de links em nosso site, podemos receber uma comissão de afiliado sem nenhum custo adicional para você. Saiba mais sobre nossa política editorial e monetização.
💡

⚡ Lógica Condicional e Consultas Aninhadas

  • ▶O If-Else do Banco de Dados: O comando CASE WHEN permite categorizar, criar flags e classificar dados dinamicamente sem alterar as tabelas físicas.
  • ▶Subqueries no WHERE: Permite filtrar linhas comparando-as contra o resultado de uma consulta interna (ex: clientes que compraram acima da média geral).
  • ▶Subqueries no FROM (Tabelas Derivadas): Trata o resultado de uma query aninhada como se fosse uma tabela temporária em memória, exigindo alias obrigatório.
  • ▶Subqueries no SELECT (Escalares): Úteis para projetar uma métrica pontual por linha, mas devem ser usadas com cautela para evitar degradação de performance.

Chegamos à sexta e última aula da nossa Trilha Didática de SQL!

Até aqui, você aprendeu a extrair registros, aplicar filtros lógicos rigorosos, unir tabelas com JOINs e resumir milhões de linhas com GROUP BY. Agora, vamos adicionar as duas ferramentas que transformam consultas SQL convencionais em verdadeiras peças de programação algorítmica: a lógica condicional com CASE WHEN e o uso de Subqueries (consultas aninhadas).

Com esses dois recursos, você conseguirá classificar clientes por categorias de fidelidade na hora da consulta e comparar registros contra métricas globais sem precisar fazer múltiplos passos manuais.

┌────────────────────────────────────────────────────────────────────────┐
│                   LÓGICA CONDICIONAL E CONSULTAS ANINHADAS             │
│                                                                        │
│   CASE WHEN: Classificação Dinâmica                                    │
│   [Valor do Saldo] ──► WHEN > 5000 THEN 'VIP' ──► [Nova Coluna]        │
│                                                                        │
│   SUBQUERY: Consulta dentro de Consulta                                │
│   SELECT nome FROM clientes                                            │
│   WHERE saldo > ( SELECT AVG(saldo) FROM clientes );                   │
│                          │                                             │
│                          ▼                                             │
│               [Calcula a Média Primeiro]                               │
└────────────────────────────────────────────────────────────────────────┘

1. Lógica Condicional na Prática: O Comando CASE WHEN

O CASE WHEN funciona exatamente como a estrutura condicional IF / ELSE IF / ELSE presente em linguagens de programação como JavaScript, Python ou PHP. Ele avalia uma sequência de condições e retorna o primeiro valor verdadeiro que encontrar.

Sintaxe Básica do CASE WHEN

SELECT 
  nome,
  saldo,
  CASE 
    WHEN saldo >= 5000.00 THEN 'Cliente VIP (Diamante)'
    WHEN saldo >= 1500.00 THEN 'Cliente Regular (Ouro)'
    WHEN saldo > 0.00     THEN 'Cliente Básico (Prata)'
    ELSE 'Sem Saldo / Negativado'
  END AS categoria_cliente
FROM clientes;

Essa classificação é calculada dinamicamente durante a leitura: nenhuma coluna nova precisa ser adicionada fisicamente à tabela do banco de dados.

Usando CASE WHEN Dentro de Funções de Agregação

Uma das técnicas mais elegantes em relatórios analíticos é usar o CASE WHEN dentro do SUM ou COUNT para transformar linhas em colunas (Pivot dinâmico):

-- Calcula o total de faturamento separado por status em uma única linha
SELECT 
  SUM(CASE WHEN status = 'pago' THEN valor_total ELSE 0 END) AS total_recebido,
  SUM(CASE WHEN status = 'pendente' THEN valor_total ELSE 0 END) AS total_a_receber,
  SUM(CASE WHEN status = 'cancelado' THEN valor_total ELSE 0 END) AS total_perdido
FROM pedidos;

2. Subqueries: O Que São e Onde Usar?

Uma Subquery (ou subconsulta) é simplesmente uma consulta SELECT aninhada dentro de outra instrução SQL. A consulta interna é executada primeiro, e seu resultado é entregue como insumo para a consulta externa.

Podemos utilizar subqueries principalmente em três lugares:


A. Subquery no WHERE (Filtros Comparativos Dinâmicos)

Imagine que você precise encontrar todos os clientes cujo saldo é maior do que a média de saldo de todos os clientes da empresa.

Como a média não é um número fixo (ela muda a cada novo cliente cadastrado), não podemos escrever WHERE saldo > 1500. Usamos uma subquery:

SELECT nome, saldo
FROM clientes
WHERE saldo > (
  -- Subquery interna calcula a média geral primeiro:
  SELECT AVG(saldo) FROM clientes
);

O banco primeiro calcula a média geral (por exemplo, R$ 2.100,00) e depois busca todos os clientes que possuem saldo superior a esse valor.

Operadores IN e EXISTS com Subqueries

Se a subconsulta retornar múltiplos valores em vez de um único número, podemos usar o operador IN:

-- Retorna os clientes que fizeram pedidos acima de R$ 5.000 em 2026
SELECT id, nome, email
FROM clientes
WHERE id IN (
  SELECT cliente_id 
  FROM pedidos 
  WHERE valor_total > 5000.00
);

B. Subquery no FROM (Tabelas Derivadas em Memória)

Podemos tratar o resultado de uma consulta completa como se fosse uma tabela temporária dentro da cláusula FROM.

[!IMPORTANT] Alias Obrigatório Sempre que usar uma subquery no FROM, você é obrigado a fornecer um apelido (alias) para ela, caso contrário o banco rejeitará o comando com erro de sintaxe.

-- Calcula a média geral do faturamento das cidades
SELECT AVG(faturamento_cidade) AS media_faturamento_por_cidade
FROM (
  -- Tabela derivada: agrupa o faturamento por cidade
  SELECT c.cidade, SUM(p.valor_total) AS faturamento_cidade
  FROM clientes c
  INNER JOIN pedidos p ON c.id = p.cliente_id
  GROUP BY c.cidade
) AS resumo_cidades;

C. Subquery no SELECT (Colunas Escalares Calculadas)

Uma subquery no SELECT calcula um único valor escalar para cada linha exibida:

SELECT 
  c.nome,
  (SELECT COUNT(*) FROM pedidos p WHERE p.cliente_id = c.id) AS total_pedidos_feitos
FROM clientes c;

[!WARNING] Cuidado com a Performance! Uma subquery no SELECT que referencia a tabela de fora (chamada de Subquery Correlacionada) é executada linha por linha. Em tabelas com 500 mil registros, isso significa executar 500 mil subconsultas, o que degrada a performance. Nesses cenários, prefira sempre o LEFT JOIN com GROUP BY.


✍️ Exercício de Fixação

Desafio Final: O departamento de auditoria precisa de uma listagem dos pedidos que possuem valor superior à média de todos os pedidos já realizados na história da loja. O relatório deve conter o id do pedido, o valor_total e uma coluna condicional chamada porte_pedido que exiba 'Super Pedido' se o valor for acima de R$ 3.000, e 'Pedido Padrão' caso contrário.

Como você montaria essa consulta?

-- Solução comentada:
SELECT 
  id,
  valor_total,
  CASE 
    WHEN valor_total > 3000.00 THEN 'Super Pedido'
    ELSE 'Pedido Padrão'
  END AS porte_pedido
FROM pedidos
WHERE valor_total > (
  SELECT AVG(valor_total) FROM pedidos
)
ORDER BY valor_total DESC;

🚀 Parabéns: Trilha de SQL Concluída! E Agora?

Você completou toda a jornada do SQL Básico ao Intermediário:

  1. Aula 1: SELECT, FROM e Filtros WHERE
  2. Aula 2: Buscas com LIKE/ILIKE, Ordenação e Paginação
  3. Aula 3: Manipulação com INSERT, UPDATE e DELETE
  4. Aula 4: Modelagem Relacional (PK/FK) e o Guia Visual de JOINs
  5. Aula 5: Agregações, COUNT Estratégico e GROUP BY / HAVING
  6. Aula 6: Lógica Condicional com CASE WHEN e Subqueries

💡 O Segredo dos Mestres em Banco de Dados: O Estudo Não Para Aqui!

O SQL é uma linguagem com décadas de maturidade e continua sendo o alicerce fundamental de engenharia de dados, desenvolvimento backend, ciência de dados e inteligência artificial.

Para continuar evoluindo e alcançar o nível Avançado, recomendamos seus próximos passos de estudo:

  • Funções de Janela (Window Functions): ROW_NUMBER(), RANK(), DENSE_RANK(), LEAD() e LAG();
  • Common Table Expressions (CTEs): A cláusula WITH para organizar queries complexas e recursividade;
  • Otimização e Performance: Criação de Índices (B-Tree, GIN), leitura de planos de execução (EXPLAIN ANALYZE) e tuning de banco de dados;
  • Infraestrutura e Servidores: Conheça nossa curadoria com as Top 5 Melhores Hospedagens VPS Baratas para Aplicações Web em 2026 para subir seus próprios servidores de banco de dados PostgreSQL ou MySQL na nuvem!

Visite o nosso Hub da Área Didática para navegar por todas as aulas e salvar o material nos seus favoritos!

TK

Thalisson

Criador de Conteúdo & Pesquisador

Profissional de TI & Entusiasta de Tecnologia

Atua diariamente com tecnologia há mais de 4 anos, lidando na prática com rotinas de hardware, sistemas e desenvolvimento de software. Todas as análises e guias são baseados em pesquisas aprofundadas em fontes confiáveis e testes no mundo real.