SQL HAVING

A gerente da Loja Aurora quer abrir um ponto de retirada nas cidades que já têm pelo menos 7 clientes. A Ana sabe contar clientes por cidade com GROUP BY, mas agora precisa descartar as cidades pequenas. A primeira tentativa dela é um WHERE COUNT(*) >= 7, e o SQLite responde com erro. O WHERE filtra linhas, uma por uma, antes de os grupos existirem. Para filtrar grupos, pelo resultado de uma agregada, o SQL tem outra cláusula: o HAVING ("tendo", em inglês), lido como "fique só com os grupos que tenham…".

A ideia: a peneira depois das pilhas

Lembra das fichas de cliente separadas em pilhas, uma por cidade (aula GROUP BY)? O HAVING é uma peneira de pilhas: depois de montadas e contadas, você olha cada pilha e só guarda as que passam no teste. Já o WHERE é uma peneira de fichas: tira fichas da mesa antes de montar as pilhas.

1. O primeiro HAVING: cidades com 7 clientes ou mais

SELECT cidade, COUNT(*) AS clientes
FROM clientes
GROUP BY cidade
HAVING COUNT(*) >= 7;

GROUP BY cidade

Monta as 8 pilhas, uma por cidade, e conta cada uma.

HAVING

"Tendo": a peneira dos grupos. Vem logo depois do GROUP BY.

COUNT(*) >= 7

O teste, feito em cada grupo: o grupo fica se tiver 7 linhas ou mais. Recife (2) e as cidades com 1 cliente são descartadas.

Sobraram Fortaleza, São Paulo e Teresina. Os grupos descartados somem por inteiro do resultado: não aparecem nem com zero.

SELECT categoria_id, COUNT(*) AS produtos
FROM produtos
GROUP BY categoria_id;

SELECT categoria_id, COUNT(*) AS produtos
FROM produtos
GROUP BY categoria_id
HAVING COUNT(*) >= 6;

2. HAVING com outras agregadas

Qualquer agregada serve no teste. Os pedidos com mais de R$ 500 em produtos:

SELECT pedido_id,
       ROUND(SUM(quantidade * preco_unitario), 2) AS total
FROM itens_pedido
GROUP BY pedido_id
HAVING SUM(quantidade * preco_unitario) > 500
ORDER BY total DESC;

Seis pedidos, do maior para o menor. Repare que o ORDER BY vem depois do HAVING: primeiro a peneira, depois a arrumação.

Uma agregada que nem aparece no resultado

O teste do HAVING não precisa estar no SELECT. Quantos produtos têm as categorias "caras", as de preço médio acima de R$ 50?

SELECT categoria_id, COUNT(*) AS produtos
FROM produtos
GROUP BY categoria_id
HAVING AVG(preco) > 50;

Eletrônicos (2) e Casa e Cozinha (3). A média foi calculada para cada grupo, usada na peneira e não foi mostrada. A documentação do SQLite diz isso com todas as letras: o HAVING pode usar valores, até agregadas, que não estão no resultado.

3. WHERE e HAVING juntos

A gerente muda de ideia: o ponto de retirada é para os clientes comuns (os VIPs já recebem em casa). Agora são duas peneiras, uma de cada tipo:

SELECT cidade, COUNT(*) AS clientes
FROM clientes
WHERE vip = 0
GROUP BY cidade
HAVING COUNT(*) >= 6;

Siga o caminho das linhas:

1. FROM clientes: 30 linhas.
2. WHERE vip = 0: tira as 5 fichas de VIP. Sobram 25 linhas.
3. GROUP BY cidade: as 25 viram 8 pilhas (Teresina 8, São Paulo 6, Fortaleza 5, Recife 2 e quatro cidades com 1).
4. HAVING COUNT(*) >= 6: ficam as pilhas com 6 ou mais. Sobram Teresina e São Paulo.
5. SELECT: escreve a cidade e a contagem de cada pilha que sobrou.

Compare com o resultado da seção 1: Fortaleza tinha 7 clientes, mas 2 são VIP. Sem eles, a pilha de Fortaleza ficou com 5 e não passou na peneira. O WHERE mudou as pilhas, e com isso mudou o que o HAVING viu.

A ordem lógica completa

Agora você conhece todas as cláusulas desta parte do guia. A ordem em que o banco as "pensa":

A regra de ouro sai da tabela: se o filtro usa uma agregada, ele vai no HAVING; se não usa, vai no WHERE. E a ordem de escrever é SELECT … FROM … WHERE … GROUP BY … HAVING … ORDER BY … LIMIT.

Um exemplo com todas as cláusulas: entre os pedidos de 2025 (os de id 33 a 64), os produtos que venderam 4 unidades ou mais, do mais vendido para o menos, só os 5 primeiros:

SELECT produto_id, SUM(quantidade) AS unidades
FROM itens_pedido
WHERE pedido_id BETWEEN 33 AND 64
GROUP BY produto_id
HAVING SUM(quantidade) >= 4
ORDER BY unidades DESC, produto_id
LIMIT 5;

4. Formas diferentes, e qual escolher

Filtro sem agregada: WHERE ou HAVING?

Um teste que não usa agregada, sobre a coluna do grupo, funciona nos dois lugares:

SELECT estado, COUNT(*) AS clientes
FROM clientes
WHERE estado = 'PI'
GROUP BY estado;

SELECT estado, COUNT(*) AS clientes
FROM clientes
GROUP BY estado
HAVING estado = 'PI';

Mesmo resultado, mas o WHERE é melhor: ele joga fora as linhas de outros estados antes de agrupar, e o banco trabalha menos. No HAVING, pela ordem lógica, o banco monta e conta as 4 pilhas para depois jogar 3 fora. Deixe o HAVING para os testes com agregadas.

O apelido no HAVING

SELECT cidade, COUNT(*) AS clientes
FROM clientes
GROUP BY cidade
HAVING clientes >= 7;

O SQLite aceita o apelido clientes no HAVING, mesmo ele sendo criado no SELECT, que vem depois na ordem lógica. É prático, mas não é padrão (veja "Nos outros bancos"). Repetir a agregada, HAVING COUNT(*) >= 7, funciona em todos.

5. HAVING sem GROUP BY

Desde a versão 3.39, o SQLite aceita HAVING sem GROUP BY: a tabela inteira vira um grupo só, e o HAVING decide se essa única linha aparece ou não.

SELECT COUNT(*) AS clientes
FROM clientes
HAVING COUNT(*) > 3;

SELECT COUNT(*) AS clientes
FROM clientes
HAVING COUNT(*) > 100;

Na primeira, 30 > 3 e a linha aparece; na segunda, o resultado tem zero linhas. Repare na diferença: sem o HAVING, uma consulta com agregada sempre devolve uma linha; com ele, pode não devolver nenhuma. Na prática, quase sempre o HAVING vem com GROUP BY.

Quando dá errado

SELECT cidade, COUNT(*)
FROM clientes
WHERE COUNT(*) >= 7
GROUP BY cidade;

SELECT cidade, COUNT(*) AS n
FROM clientes
WHERE n >= 7
GROUP BY cidade;

SELECT cidade, COUNT(*)
FROM clientes
HAVING COUNT(*) >= 7
GROUP BY cidade;

SELECT cidade
FROM clientes
HAVING COUNT(*) > 3;

SELECT pedido_id
FROM itens_pedido
GROUP BY pedido_id
HAVING SUM(quantidade * preco_unitario) = 30.94;

SELECT pedido_id
FROM itens_pedido
GROUP BY pedido_id
HAVING ROUND(SUM(quantidade * preco_unitario), 2) = 30.94;

SELECT cidade, COUNT(*) AS clientes
FROM clientes
GROUP BY cidade
HAVING nome LIKE 'Ana%';

SELECT cidade, COUNT(*) AS clientes
FROM clientes
WHERE nome LIKE 'Ana%'
GROUP BY cidade;

SELECT cidade, COUNT(*) AS clientes
FROM clientes
GROUP BY cidade
HAVING COUNT(*) >= 7;   -- HAVING clientes >= 7 não vale aqui

Referência rápida

Exercícios

Missão final: os clientes mais fiéis

SELECT cliente_id, COUNT(*) AS pedidos
FROM pedidos
GROUP BY cliente_id;

SELECT cliente_id, COUNT(*) AS pedidos
FROM pedidos
GROUP BY cliente_id
HAVING COUNT(*) >= 4;

Doze clientes ganham o brinde. Para mostrar o nome deles em vez do cliente_id, falta juntar a tabela clientes, o que você aprende em INNER JOIN. E se a gerente quiser agrupar por cidade e por VIP ao mesmo tempo, o próximo passo é Agrupando por Mais de uma Coluna.

Resumo

• HAVING filtra grupos, depois do GROUP BY; o WHERE filtra linhas, antes. Os grupos que não passam somem do resultado.
• Filtro com agregada (COUNT, SUM, AVG…) vai no HAVING; sem agregada, no WHERE. Agregada no WHERE dá misuse of aggregate.
• A ordem lógica: FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT. O WHERE muda as pilhas que o HAVING vê.
• O HAVING pode usar agregadas que não estão no SELECT.
• Para comparar somas de dinheiro com =, use ROUND(SUM(…), 2).
• Apelido no HAVING funciona no SQLite (e no MySQL), não no PostgreSQL; repetir a agregada funciona em todos. Coluna comum no HAVING testa uma linha qualquer do grupo: use WHERE.