Summary  
This chapter introduces the HAVING clause in SQL to filter grouped query results based on aggregate functions after performing a GROUP BY, since WHERE cannot be used with aggregates.  

General domain of usage  
Database reporting and analytics

O sistema de informações escolares está sendo revisado para garantir a consistência e precisão dos dados.
Como parte dessa revisão, uma nova tarefa de análise de dados foi atribuída.

Durante verificações de rotina, foi descoberto que alguns registros de alunos contêm mais de uma entrada de nota, mesmo que o sistema tenha sido projetado para armazenar apenas uma nota por aluno.

Sua tarefa é ajudar a identificar esses casos para uma revisão interna adicional.

Pense em **como você pode fazer isso**. Você pode começar considerando que é possível realizar essa tarefa utilizando uma cláusula `WHERE`, e ela ficaria parecida com isto:

SELECT student_surname
FROM student_grades
WHERE COUNT(grade) > 1

Mas, como você pode ver, ocorre um <span style="color:red">erro</span> indicando que **não é possível usar funções de agregação** dentro de uma cláusula `WHERE`. É nesse caso que você precisará da cláusula `HAVING`.

Suponha que seja necessário **obter os departamentos** onde o **salário médio** dos funcionários é **inferior a $70.000 por ano**.
Para isso, será necessário utilizar uma função de agregação e a cláusula `HAVING`:

SELECT department
FROM employees
GROUP BY department
HAVING AVG(salary) < 70000

O resultado é um departamento na resposta utilizando a cláusula `HAVING`, onde **uma condição é definida para a coluna** utilizada na agregação dos dados.



**Para utilizar agregação de dados** dentro da cláusula `HAVING`, é necessário que haja **agrupamento de dados na consulta**. Como na consulta acima, os dados foram agrupados pela coluna `department`.

Nota

A seguir, uma sintaxe mais generalizada da cláusula `HAVING` e quando é mais indicada sua utilização:

```sql
SELECT column1, column2 --(optional)
FROM table
GROUP BY column1
HAVING AGG(column_n) --(condition)

-- This will cause an error
```

Aqui está uma breve análise da **principal diferença** entre as cláusulas `WHERE` e `HAVING` e quando usar cada uma delas:

1. A cláusula `WHERE` é usada **antes** da agregação de dados, enquanto a cláusula `HAVING` é usada **após** a agregação de dados;
2. A cláusula `WHERE` é escrita **antes** do `GROUP BY`, enquanto a cláusula `HAVING` é escrita **após** o `GROUP BY`.

Essas são as **duas principais diferenças** que você precisa lembrar para o uso correto da cláusula `HAVING`. Agora, retorne à tarefa dada pela escola.

import unittest
import psycopg2
import pandas as pd

class TestPostgresQuery(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.connection = psycopg2.connect(
            host="localhost",
            user="agent",
            password="qwerty",
            dbname="testdb",
            sslmode="disable"
        )
        cls.cursor = cls.connection.cursor()

    def test_query_output_is_correct(self):
        """Check if the query returns only surnames of students with more than 1 grade, sorted alphabetically."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Get expected surnames
        solution_query = '''
            SELECT student_surname
            FROM student_grades
            GROUP BY student_surname
            HAVING COUNT(grade) > 1
            ORDER BY student_surname;
        '''
        self.cursor.execute(solution_query)
        expected = [row[0] for row in self.cursor.fetchall()]
        # Get user result
        self.cursor.execute(query)
        result = [row[0] for row in self.cursor.fetchall()]
        condition = result == sorted(expected)
        if not condition:
            failure_msg = f"Query result is incorrect.\\nExpected: {expected}\\nGot: {result}"
        else:
            failure_msg = ""
        _dynamic_test(
            self,
            condition,
            "Query output is correct and sorted alphabetically.",
            failure_msg
        )

    def test_only_one_column(self):
        """Check that only one column (student_surname) is returned."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute(query)
        columns = [desc[0] for desc in self.cursor.description]
        condition = columns == ["student_surname"]
        if not condition:
            failure_msg = f"Query columns are incorrect. Expected ['student_surname'], got {columns}."
        else:
            failure_msg = ""
        _dynamic_test(
            self,
            condition,
            "Query returns only 'student_surname' column.",
            failure_msg
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


test_solution.py

Este curso é ideal para quem já possui conhecimentos básicos de SQL e deseja aprofundar-se em conceitos mais avançados para criar consultas mais poderosas. Ao longo do curso, você se familiarizará com o agrupamento de dados e a filtragem de dados agrupados. Você também aprenderá a trabalhar com várias tabelas simultaneamente, incluindo como combiná-las. Além disso, explorará diferentes tipos de junções de tabelas e como aplicá-las na prática.

Nesta seção, você aprenderá como agrupar e gerenciar dados de forma eficaz. Será apresentado o operador GROUP BY para agrupamento de dados. Além disso, você aprenderá a filtrar dados agrupados utilizando o operador HAVING.

Você aprenderá sobre subconsultas aninhadas, como criá-las e como utilizá-las de forma eficaz.

Aqui, você aprenderá como combinar várias tabelas, permitindo trabalhar com uma tabela unificada e simplificar a criação de consultas.

Aprenda os fundamentos da Linguagem de Definição de Dados (DDL) e da Linguagem de Manipulação de Dados (DML) em SQL, incluindo como criar, modificar e excluir objetos de banco de dados, assim como inserir, atualizar e excluir dados em tabelas.

Cláusula Having

Instruções Resumidas

Solução