Database
 sql >> Base de Dados >  >> RDS >> Database

Cláusula SQL HAVING para iniciantes


Em SQL, o HAVING A cláusula pode ser usada para especificar uma condição de pesquisa para um grupo ou um agregado.

O HAVING A cláusula é normalmente usada com o GROUP BY cláusula. Nos casos em que não é, há um grupo único e agregado implícito.

O HAVING cláusula é semelhante à WHERE cláusula, exceto que WHERE filtra linhas individuais, enquanto HAVING grupos de filtros. O WHERE cláusula filtra dados antes é agrupado, enquanto HAVING filtra dados depois ele é agrupado.

Exemplo 1 – HAVING com COUNT()


Suponha que temos a seguinte tabela:
SELECT * FROM Pets;

Resultado:
+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+

Poderíamos executar a seguinte consulta nesta tabela:
SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;

Resultado:
+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
+-------------+---------+

Neste caso, usamos o HAVING cláusula em conjunto com o GROUP BY cláusula para retornar apenas as linhas que têm um COUNT(PetTypeId) maior que 2 . Isso usa o COUNT() function, que é uma função agregada padrão SQL disponível na maioria dos principais RDBMSs.

Se omitirmos o HAVING cláusula, obtemos mais um resultado:
SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
ORDER BY Count DESC;

Resultado:
+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
| 1           | 1       |
+-------------+---------+

Exemplo 2 – HAVING com SUM()


Aqui está outro exemplo. Desta vez, usamos o HAVING cláusula com a SUM() função, que é outra função agregada disponível na maioria dos principais RDBMSs (veja SQLite SUM() para outro exemplo). 
SELECT
    CountryCode,
    District,
    SUM(Population) AS Population
FROM City
WHERE CountryCode IN ('AGO', 'ARE', 'AUS')
GROUP BY CountryCode, District
HAVING SUM(Population) > 1000000
ORDER BY CountryCode;

Resultado:
+---------------+-----------------+--------------+
| CountryCode   | District        | Population   |
|---------------+-----------------+--------------|
| AGO           | Luanda          | 2022000      |
| AUS           | New South Wales | 3993949      |
| AUS           | Queensland      | 1805236      |
| AUS           | Victoria        | 2990711      |
| AUS           | West Australia  | 1096829      |
+---------------+-----------------+--------------+

Exemplo 3 – HAVING com o IN Operador


Você não está limitado apenas ao operador ) para iniciantes”>maior que o operador (> ) ao usar o HAVING cláusula. Você pode usar os mesmos operadores que você pode usar com o WHERE cláusula (como = , ) Operator for Beginners">< , =) Operator for Beginners">>= , IN , LIKE , etc).

Aqui está um exemplo que usa o IN operador para especificar um intervalo de valores agregados a serem retornados. 
SELECT
    CountryCode,
    District,
    SUM(Population) AS Population
FROM City
WHERE CountryCode IN ('AGO', 'ARE', 'AUS')
GROUP BY CountryCode, District
HAVING SUM(Population) IN (2022000, 3993949, 2990711)
ORDER BY CountryCode;

Resultado:
+---------------+-----------------+--------------+
| CountryCode   | District        | Population   |
|---------------+-----------------+--------------|
| AGO           | Luanda          | 2022000      |
| AUS           | New South Wales | 3993949      |
| AUS           | Victoria        | 2990711      |
+---------------+-----------------+--------------+

Exemplo 4 – HAVING sem um GROUP BY Cláusula


Embora HAVING geralmente é usado com o GROUP BY cláusula, ela também pode ser usada sem ela. Quando usado sem ele, há um grupo único e agregado implícito.

Os resultados obtidos podem depender do seu DBMS, mas aqui está um exemplo que foi feito no SQL Server. 
SELECT
    SUM(Population) AS Population
FROM City
HAVING SUM(Population) > 2000000;

Resultado:
+--------------+
| Population   |
|--------------|
| 1429559884   |
+--------------+

Este exemplo simplesmente retorna a população agregada de todas as cidades na tabela.

Veja o que acontece se trocarmos o operador maior que (> ) com um operador menor que (< ). 
SELECT
    SUM(Population) AS Population
FROM City
HAVING SUM(Population) < 2000000;

Resultado:
(0 rows affected)