> ## Documentation Index
> Fetch the complete documentation index at: https://villagesql.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# MySQL HAVING

> Como a cláusula HAVING do MySQL filtra grupos depois que o GROUP BY os construiu, o que a separa do WHERE e por que ela pode nomear um alias de coluna quando o WHERE não pode.

> [card] [VillageSQL is a drop-in replacement for MySQL with extensions.](https://villagesql.com/docs/en/8.4/stable/install-server.md)
>
> All examples on this page work on VillageSQL. Install Now →

`WHERE` descarta linhas antes de elas serem agrupadas. `HAVING` descarta grupos
inteiros depois de eles serem construídos. Essa única frase é a lição inteira, e tudo
abaixo é consequência dela.

Abra o cliente com `mysql -u root -p sakila` antes de começar.

## Como o HAVING funciona

```sql theme={null}
SELECT GROUPING_COLUMN, AGGREGATE_FUNCTION(COLUMN_NAME)
FROM TABLE_NAME
GROUP BY GROUPING_COLUMN
HAVING GROUP_CONDITION;
```

Substitua `GROUPING_COLUMN` pela coluna que define os grupos, `TABLE_NAME`
pela tabela, `AGGREGATE_FUNCTION(COLUMN_NAME)` pelo que calcular por
grupo, e `GROUP_CONDITION` por um teste que se aplica a um grupo inteiro, como
`COUNT(*) > 200`.

O servidor constrói cada grupo primeiro, depois mantém os grupos em que a condição
é verdadeira.

## Exemplos

### Manter só os grupos grandes

```sql theme={null}
SELECT rating, COUNT(*) AS films
FROM film
GROUP BY rating
HAVING COUNT(*) > 200
ORDER BY rating;
```

```text theme={null}
+--------+-------+
| rating | films |
+--------+-------+
| PG-13  |   223 |
| NC-17  |   210 |
+--------+-------+
2 rows in set (0.01 sec)
```

Todas as 5 classificações foram contadas. 3 dos grupos falharam no teste em seguida e foram
descartados.

### HAVING pode usar um alias

Um alias nomeia uma coluna do resultado, e quando o `HAVING` roda o resultado
já existe.

```sql theme={null}
SELECT rating, COUNT(*) AS films
FROM film
GROUP BY rating
HAVING films > 200
ORDER BY rating;
```

```text theme={null}
+--------+-------+
| rating | films |
+--------+-------+
| PG-13  |   223 |
| NC-17  |   210 |
+--------+-------+
2 rows in set (0.00 sec)
```

As mesmas 2 linhas, e menos para escrever. `WHERE` não consegue fazer isso, porque roda
antes de existir um resultado para nomear: a lição sobre [WHERE](https://villagesql.com/docs/pt-BR/tutorial/where.md) mostra o
`ERROR 1054` que você recebe em vez disso.

### As duas cláusulas em uma consulta

A maioria das consultas reais usa as duas: `WHERE` para escolher as linhas, `HAVING` para escolher os
grupos.

```sql theme={null}
SELECT rating, COUNT(*) AS films
FROM film
WHERE length > 120
GROUP BY rating
HAVING COUNT(*) > 100
ORDER BY rating;
```

```text theme={null}
+--------+-------+
| rating | films |
+--------+-------+
| PG-13  |   118 |
+--------+-------+
1 row in set (0.00 sec)
```

`WHERE` manteve os filmes com mais de 120 minutos, o agrupamento os contou por classificação,
e `HAVING` manteve a única classificação com mais de 100 deles.

## Um agregado não pode ir no WHERE

Mova essa condição do `HAVING` para o `WHERE` e o servidor a recusa de imediato.

```sql theme={null}
SELECT rating, COUNT(*) AS films
FROM film
WHERE COUNT(*) > 200
GROUP BY rating;
```

```text theme={null}
ERROR 1111 (HY000): Invalid use of group function
```

`WHERE` roda antes do agrupamento, então não existe contagem para ele testar. O mesmo
vale para o alias de um agregado, com um erro diferente.

```sql theme={null}
SELECT rating, COUNT(*) AS films
FROM film
WHERE films > 200
GROUP BY rating;
```

```text theme={null}
ERROR 1054 (42S22): Unknown column 'films' in 'where clause'
```

Os dois significam a mesma coisa e os dois se corrigem do mesmo jeito: mova a condição para o
`HAVING`.

`ERROR 1054` em um alias no `WHERE` tem 2 remédios, e o agregado é o que
os distingue. Um alias de uma expressão simples pode ser repetido no `WHERE`,
como a lição sobre [WHERE](https://villagesql.com/docs/pt-BR/tutorial/where.md) mostra. Um alias de um agregado
não pode ser repetido ali de jeito nenhum, por causa do `ERROR 1111` acima, então ele tem de
ir para o `HAVING`.

## Qual cláusula testa o quê

| Cláusula | Roda | Testa | Exemplo |
| - | - | - | - |
| `WHERE` | antes do agrupamento | 1 linha | `WHERE length > 120` |
| `HAVING` | depois do agrupamento | 1 grupo inteiro | `HAVING COUNT(*) > 50` |

Coloque uma condição no `WHERE` sempre que ela testar uma linha, e reserve o `HAVING` para o que
só faz sentido depois que um grupo existe. Essa também é a disposição mais barata, por
razões que o guia
[Desempenho de GROUP BY no MySQL](https://villagesql.com/docs/pt-BR/guides/group-by-having.md) mede.

> [!NOTE]
>
> Nomear um alias da lista de seleção no `HAVING` é uma extensão do MySQL. Repita o
> agregado em vez do alias quando o mesmo SQL tiver de rodar em outro
> banco de dados.

## Resumo

* Use `HAVING` para descartar grupos inteiros, e `WHERE` para descartar linhas.
* Espere que o `HAVING` rode depois do `GROUP BY`, por isso ele pode testar um agregado.
* Leia `ERROR 1111` como um agregado no `WHERE` que pertence ao `HAVING`.
* Nomeie um alias de coluna no `HAVING`, o que o `WHERE` não pode fazer.
* Coloque uma condição no `WHERE` quando ela testar uma linha em vez de um grupo.

## Veja também

* [GROUP BY](https://villagesql.com/docs/pt-BR/tutorial/group-by.md) — construindo os grupos que esta cláusula filtra
* [WHERE](https://villagesql.com/docs/pt-BR/tutorial/where.md) — a cláusula que roda primeiro
* [Funções de agregação](https://villagesql.com/docs/pt-BR/tutorial/aggregate-functions.md) — o que uma condição de grupo normalmente testa
* [Desempenho de GROUP BY no MySQL](https://villagesql.com/docs/pt-BR/guides/group-by-having.md) — o custo de agrupar antes de filtrar


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.