🇯🇵 日本語 | 🇺🇸 English | 🇪🇸 Español | 🇵🇹 Português | 🇹🇭 ไทย | 🇨🇳 中文

Domine a Cláusula HAVING do SQL: Um Mergulho Profundo na Filtragem de Dados Agrupados

Quando você se acostuma com a cláusula GROUP BY do SQL, pode realizar agregações úteis, como contar produtos por categoria ou pedidos por cliente. Mas a análise de dados verdadeiramente começa a partir daí. Inevitavelmente, você encontrará situações em que desejará filtrar ainda mais com base nesses resultados agregados, fazendo perguntas como: "Quem são nossos melhores clientes com mais pedidos?" ou "Quais categorias populares têm o preço médio mais alto?".

A solução para essa "filtragem após o agrupamento" é o nosso tópico principal de hoje: a cláusula HAVING. Quando usada com GROUP BY, a HAVING melhora drasticamente a precisão e a profundidade da sua análise de dados. É a ferramenta perfeita que atende exatamente ao que você precisa.

Este artigo explicará detalhadamente o papel и o uso da cláusula HAVING do zero, focando na sua diferença em relação à cláusula WHERE, um ponto comum de confusão para muitos aprendizes de SQL. Através de numerosos exemplos de "copiar, colar e executar" (completos com um ambiente SQL online!), você terá aquele momento "Aha!" e experimentará em primeira mão como funciona, levando suas habilidades de agregação de dados para o próximo nível!

Preparação: Vamos Configurar Nossos Dados de Pedidos de Amostra

Antes de mergulhar na teoria, vamos construir uma base prática. Usaremos uma tabela orders que imita o histórico de pedidos de um site de comércio eletrônico. Ela contém dados práticos como ID do cliente, categoria do produto, preço e data do pedido. Você pode copiar toda a instrução SQL abaixo para executar em seu próprio ambiente ou usá-la na seção "Playground Interativo" mais adiante.

-- Exclui a tabela se ela existir (para permitir testes repetidos)
DROP TABLE IF EXISTS orders;

-- Cria a tabela orders
CREATE TABLE orders (
  order_id INTEGER PRIMARY KEY,
  customer_id INTEGER NOT NULL,
  product_category TEXT NOT NULL,
  price INTEGER NOT NULL,
  order_date DATE NOT NULL
);

-- Insere os dados
INSERT INTO orders (order_id, customer_id, product_category, price, order_date) VALUES
(1, 101, 'Periféricos de PC', 15000, '2025-05-10'),
(2, 102, 'Livros', 3200, '2025-05-11'),
(3, 101, 'Periféricos de PC', 250000, '2025-05-12'),
(4, 103, 'Eletrodomésticos', 88000, '2025-05-15'),
(5, 102, 'Livros', 4500, '2025-05-20'),
(6, 101, 'Eletrodomésticos', 120000, '2025-06-01'),
(7, 104, 'Periféricos de PC', 8000, '2025-06-05'),
(8, 102, 'Vestuário', 7800, '2025-06-08'),
(9, 103, 'Periféricos de PC', 320000, '2025-06-10'),
(10, 105, 'Livros', 2900, '2025-06-15'),
(11, 101, 'Livros', 3500, '2025-06-20'),
(12, 103, 'Eletrodomésticos', 35000, '2025-06-22');

Esses dados incluem clientes que fizeram várias compras (ex: IDs de cliente 101, 102, 103) e categorias compradas por vários clientes (ex: Periféricos de PC, Livros), tornando-os ideais para observar o comportamento do GROUP BY e do HAVING.

O Conceito Central: A Diferença Definitiva Entre WHERE e HAVING

A maior chave para entender a cláusula HAVING é compreender claramente sua divisão de trabalho com a cláusula WHERE. Embora ambas sejam usadas para "filtragem", o momento e o alvo de sua filtragem são completamente diferentes.

Vamos ilustrar essa diferença usando a analogia de uma cozinha de restaurante.

Ordem de Operações do SQL: Uma Analogia de Restaurante

  1. Junções de Tabela (FROM, JOIN): Primeiro, todos os ingredientes (dados) são reunidos na cozinha.
  2. A Cláusula WHERE: O Chef chega. Antes de começar a cozinhar, o chef inspeciona os ingredientes individuais e descarta qualquer um que не atenda aos critérios, dizendo: "Não posso usar este peixe para o carpaccio de hoje".
  3. A Cláusula GROUP BY: O chef usa os ingredientes aprovados para criar vários pratos (grupos), como saladas, massas e pratos de carne.
  4. A Cláusula HAVING: O Crítico Gastronômico chega. Com os pratos finalizados (grupos) dispostos na mesa, o crítico decide quais avaliar, dizendo: "Só vou provar pratos que custam mais de R$100".

Como esta analogia mostra, os dois pontos mais importantes são:

Por causa disso, condições que usam funções de agregação como COUNT() ou SUM() só fazem sentido para grupos e, portanto, só podem ser usadas na cláusula HAVING. Você não pode escrever algo como WHERE COUNT(*) > 10.

Na Prática: Filtrando Resultados Agregados com a Cláusula HAVING

Agora, vamos ver o poder da cláusula HAVING em ação com código real. Primeiro, usaremos GROUP BY para agregar o "número de pedidos por cliente". Este será nosso resultado base antes de aplicar a cláusula HAVING.

-- Primeiro, sem HAVING, vamos contar os pedidos por cliente
SELECT
  customer_id,
  COUNT(order_id) AS order_count
FROM
  orders
GROUP BY
  customer_id;

Resultado:

customer_id | order_count
------------|-------------
101         | 4
102         | 3
103         | 3
104         | 1
105         | 1

A partir deste resultado, suponha que queiramos "extrair apenas nossos melhores clientes que têm 3 ou mais pedidos". É aqui que a cláusula HAVING entra. Aplicamos uma condição ao resultado agregado, `order_count` (que é COUNT(order_id)).

-- 【HAVING + COUNT】Filtrar por clientes com 3 ou mais pedidos
SELECT
  customer_id,
  COUNT(order_id) AS order_count
FROM
  orders
GROUP BY
  customer_id
HAVING
  COUNT(order_id) >= 3;

Resultado:

customer_id | order_count
------------|-------------
101         | 4
102         | 3
103         | 3

Perfeito! Apenas os clientes com 3 ou mais pedidos (HAVING COUNT(order_id) >= 3) foram filtrados. Este é o uso fundamental da cláusula HAVING.

Exemplos Avançados: Condições com `SUM` e `AVG`

A cláusula HAVING не se limita a COUNT. Ela pode, é claro, ser combinada com outras funções de agregação como SUM (total) e AVG (média). Isso permite uma análise de dados mais sofisticada.

【HAVING + SUM】Filtrando categorias com vendas totais acima de 100.000

Para descobrir "quais categorias mais contribuem para nossa receita", vamos calcular as vendas totais por categoria e, em seguida, visualizar apenas as categorias que excedem 100.000.

-- 【HAVING + SUM】Filtrar por categorias com vendas totais acima de 100.000
SELECT
  product_category,
  SUM(price) AS total_sales
FROM
  orders
GROUP BY
  product_category
HAVING
  SUM(price) > 100000;

Resultado:

product_category   | total_sales
--------------------|-------------
Periféricos de PC  | 593000
Eletrodomésticos   | 243000

Este resultado deixa claro que "Periféricos de PC" e "Eletrodomésticos" são os principais impulsionadores de receita.

【HAVING + AVG】Filtrando categorias com um preço médio acima de 50.000

Em seguida, para investigar "quais categorias estão vendendo itens de alto valor", vamos calcular o preço médio por categoria e extrair apenas aquelas onde a média excede 50.000.

-- 【HAVING + AVG】Filtrar por categorias com um preço médio acima de 50.000
SELECT
  product_category,
  AVG(price) AS average_price
FROM
  orders
GROUP BY
  product_category
HAVING
  AVG(price) > 50000;

Resultado:

product_category   | average_price
--------------------|---------------
Periféricos de PC  | 148250
Eletrodomésticos   | 81000

Como você pode ver, podemos avaliar as categorias de diferentes perspectivas, не apenas as vendas totais, mas também o preço médio.

A Combinação Suprema: Usando WHERE e HAVING Juntos

WHERE e HAVING não são adversários; são parceiros que trabalham juntos para alcançar uma filtragem mais complexa. Usar ambos em uma única consulta permite uma análise incrivelmente poderosa.

Nossa pergunta analítica: "Olhando apenas para os pedidos de junho de 2025 em diante, quem são os clientes cujo valor total de compra excede 100.000?"

Se dividirmos esta solicitação, veremos que há duas etapas de filtragem:

  1. Filtro pré-agrupamento: Limitar os registros a pedidos a partir de 1º de junho de 2025. → Esta é uma condição sobre registros individuais, então é um trabalho para a cláusula WHERE.
  2. Filtro pós-agrupamento: Limitar os grupos a clientes cujo valor total de compra agregado seja maior que 100.000. → Esta é uma condição sobre os grupos, então é um trabalho para a cláusula HAVING.

Aqui está o SQL correspondente:

-- 【WHERE + HAVING】Clientes com compras totais > 100k a partir de junho
SELECT
  customer_id,
  SUM(price) AS total_spent_in_june_onwards
FROM
  orders
WHERE
  order_date >= '2025-06-01'
GROUP BY
  customer_id
HAVING
  SUM(price) > 100000;

Resultado:

customer_id | total_spent_in_june_onwards
------------|-----------------------------
101         | 123500
103         | 355000

O fluxo de processamento desta consulta corresponde perfeitamente à nossa analogia do restaurante:

  1. Primeiro, WHERE order_date >= '2025-06-01' seleciona apenas os registros de pedidos de junho em diante.
  2. Em seguida, esses registros selecionados são agrupados por cliente usando GROUP BY customer_id.
  3. Finalmente, HAVING SUM(price) > 100000 filtra esses grupos, mantendo apenas aqueles onde o valor total da compra excede 100.000.

Essa colaboração entre WHERE e HAVING é indiscutivelmente onde o SQL brilha mais na análise de dados.

【Playground Interativo】SQL Fiddle: Experimente a Cláusula HAVING no seu Navegador!

Agora é hora de transformar conhecimento em uma habilidade sólida! Com o "Ambiente SQL Online" abaixo, você pode experimentar livremente com SQL diretamente no seu navegador. A tabela orders deste artigo já está carregada para você.

Experimente diferentes condições. Simplesmente mudar números, ou trocar >= por <, mostrará como os resultados mudam e aprofundará drasticamente sua compreensão.

<!DOCTYPE html>
<html lang="pt">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Playground Online da Cláusula HAVING do SQL</title>
  <style>
    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; line-height: 1.7; color: #333; max-width: 800px; margin: 2rem auto; padding: 0 1rem; }
    h1 { color: #2c3e50; }
    textarea { width: 100%; height: 200px; font-family: "SF Mono", "Consolas", monospace; font-size: 16px; padding: 12px; border: 1px solid #ccc; border-radius: 6px; box-sizing: border-box; margin-bottom: 1rem; }
    button { background-color: #8e44ad; color: white; border: none; padding: 12px 22px; font-size: 16px; border-radius: 6px; cursor: pointer; transition: background-color 0.2s; }
    button:hover { background-color: #70368b; }
    button:disabled { background-color: #bdc3c7; cursor: not-allowed; }
    #result-container { margin-top: 2rem; border: 1px solid #ddd; padding: 1rem; border-radius: 6px; background: #fdfdfd; min-height: 50px; overflow-x: auto;}
    #error-message { color: #e74c3c; font-weight: bold; }
    table { border-collapse: collapse; width: 100%; margin-top: 1rem; }
    th, td { border: 1px solid #ddd; padding: 10px; text-align: left; white-space: nowrap; }
    th { background-color: #f2f2f2; }
    tr:nth-child(even) { background-color: #f9f9f9; }
  </style>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/sql-wasm.js"></script>
</head>
<body>

  <h1>Experimente o SQL!</h1>
  <p>Insira sua consulta SQL na área de texto abaixo e clique no botão "Executar". Sinta-se à vontade para experimentar todas as diferentes consultas do artigo!</p>

  <textarea id="sql-input">-- Sinta-se à vontade para experimentar!
-- Exemplo: Filtrar pela categoria 'Periféricos de PC' (WHERE),
--          depois calcular o gasto total por cliente (GROUP BY),
--          e finalmente, mostrar apenas os clientes que gastaram mais de 200.000 (HAVING).
SELECT
  customer_id,
  SUM(price) AS total_spent_on_pc
FROM
  orders
WHERE
  product_category = 'Periféricos de PC'
GROUP BY
  customer_id
HAVING
  SUM(price) > 200000;</textarea>
  
  <button id="execute-btn">Executar</button>
  
  <div id="result-container">
    <p id="error-message"></p>
    <div id="result-output"></div>
  </div>

  <script>
    const sqlInput = document.getElementById('sql-input');
    const executeBtn = document.getElementById('execute-btn');
    const errorMsg = document.getElementById('error-message');
    const resultOutput = document.getElementById('result-output');

    let db;

    async function initDb() {
      executeBtn.disabled = true;
      executeBtn.textContent = 'Inicializando BD...';
      try {
        const SQL = await initSqlJs({
          locateFile: file => `https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/${file}`
        });
        db = new SQL.Database();
        
        const setupSql = `
          DROP TABLE IF EXISTS orders;
          CREATE TABLE orders (
            order_id INTEGER PRIMARY KEY,
            customer_id INTEGER NOT NULL,
            product_category TEXT NOT NULL,
            price INTEGER NOT NULL,
            order_date DATE NOT NULL
          );
          INSERT INTO orders (order_id, customer_id, product_category, price, order_date) VALUES
          (1, 101, 'Periféricos de PC', 15000, '2025-05-10'), (2, 102, 'Livros', 3200, '2025-05-11'),
          (3, 101, 'Periféricos de PC', 250000, '2025-05-12'), (4, 103, 'Eletrodomésticos', 88000, '2025-05-15'),
          (5, 102, 'Livros', 4500, '2025-05-20'), (6, 101, 'Eletrodomésticos', 120000, '2025-06-01'),
          (7, 104, 'Periféricos de PC', 8000, '2025-06-05'), (8, 102, 'Vestuário', 7800, '2025-06-08'),
          (9, 103, 'Periféricos de PC', 320000, '2025-06-10'), (10, 105, 'Livros', 2900, '2025-06-15'),
          (11, 101, 'Livros', 3500, '2025-06-20'), (12, 103, 'Eletrodomésticos', 35000, '2025-06-22');
        `;
        db.run(setupSql);
        
        executeBtn.disabled = false;
        executeBtn.textContent = 'Executar';
        resultOutput.innerHTML = '<p>Pronto! Sinta-se à vontade para experimentar com suas próprias consultas SQL.</p>';

      } catch (err) {
        errorMsg.textContent = 'Falha ao inicializar o banco de dados: ' + err.message;
        console.error(err);
      }
    }

    function executeSql() {
      if (!db) return;
      const sql = sqlInput.value;
      errorMsg.textContent = '';
      resultOutput.innerHTML = '';
      try {
        const results = db.exec(sql);
        if (results.length === 0) {
          resultOutput.innerHTML = '<p>Consulta executada com sucesso, mas nenhum conjunto de resultados foi retornado (ex: para INSERT, UPDATE, etc.).</p>';
          return;
        }
        results.forEach(result => {
          const table = document.createElement('table');
          const thead = document.createElement('thead');
          const tbody = document.createElement('tbody');
          const headerRow = document.createElement('tr');
          result.columns.forEach(colName => {
            const th = document.createElement('th');
            th.textContent = colName;
            headerRow.appendChild(th);
          });
          thead.appendChild(headerRow);
          result.values.forEach(row => {
            const bodyRow = document.createElement('tr');
            row.forEach(cellValue => {
              const td = document.createElement('td');
              td.textContent = cellValue === null ? 'NULL' : (typeof cellValue === 'number' ? cellValue.toLocaleString('pt-BR') : cellValue);
              bodyRow.appendChild(td);
            });
            tbody.appendChild(bodyRow);
          });
          table.appendChild(thead);
          table.appendChild(tbody);
          resultOutput.appendChild(table);
        });
      } catch (err) {
        errorMsg.textContent = 'Erro de SQL: ' + err.message;
        console.error(err);
      }
    }
    executeBtn.addEventListener('click', executeSql);
    initDb();
  </script>
</body>
</html>

Dentro do Motor SQL: A Ordem Lógica de Execução da Consulta

Para aprofundar ainda mais sua compreensão da diferença entre WHERE e HAVING, é incrivelmente útil saber a "ordem de processamento lógico" de como o SQL lida com uma consulta internamente. A ordem em que escrevemos nosso código (SELECT, FROM, WHERE...) é diferente da ordem em que o SQL o interpreta e executa.

Ordem de Execução Lógica do SQL:

  1. FROM: Primeiro, determina de qual tabela recuperar os dados.
  2. WHERE: Em seguida, filtra as linhas individuais com base em uma condição.
  3. GROUP BY: Agrupa as linhas filtradas em grupos.
  4. HAVING: Filtra os resultados agrupados com base em uma condição.
  5. SELECT: Finalmente, decide quais colunas exibir.
  6. ORDER BY: Ordena o conjunto de resultados em uma ordem específica.
  7. LIMIT: Restringe o número de linhas a serem exibidas.

Olhando para esta ordem, você pode ver claramente que WHERE vem antes de GROUP BY, e HAVING vem logo depois. Esta é a principal razão pela qual funções de agregação não podem ser usadas em WHERE, mas podem ser usadas em HAVING.

Essa ordem também explica por que você geralmente не pode usar um alias definido na cláusula SELECT (ex: SUM(price) AS total_sales) nas cláusulas WHERE ou HAVING (com algumas exceções de banco de dados). É porque a cláusula SELECT é avaliada mais tarde. (Você pode frequentemente usar aliases na cláusula ORDER BY, porque ORDER BY é avaliado após SELECT.)

Conclusão: Domine a Cláusula HAVING e Leve sua Análise de Dados para o Próximo Nível

Neste mergulho profundo, exploramos a poderosa cláusula HAVING, uma ferramenta para filtrar os resultados de uma agregação GROUP BY.

Vamos revisar os pontos principais mais uma vez:

A cláusula HAVING pode parecer uma característica menor à primeira vista. No entanto, se você consegue dominá-la ou não, fará uma enorme diferença na qualidade e profundidade dos insights que você pode extrair de seus dados. Ela permite que você responda a perguntas mais afiadas e críticas para os negócios com SQL, como: "Entre nossas categorias mais vendidas, quais são as mais lucrativas?" ou "Dentro de nossa base de usuários ativos, qual é o perfil de nossos usuários que mais gastam?".

Por favor, brinque extensivamente no playground online deste artigo e familiarize-se com a cláusula HAVING. Garanto que suas habilidades de utilização de dados como criador web melhorarão aos trancos e barrancos.

Modelos Relacionados