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

Il sistema informativo scolastico è in fase di revisione per garantire la coerenza e l'accuratezza dei dati.
Come parte di questa revisione, è stato assegnato un nuovo compito di analisi dei dati.

Durante i controlli di routine, è stato scoperto che alcuni record degli studenti contengono più di una voce di voto, anche se il sistema è progettato per memorizzare un solo voto per studente.

Il tuo compito è aiutare a identificare tali casi per ulteriori verifiche interne.

Pensa a **come puoi fare questo**. Potresti iniziare considerando che puoi farlo utilizzando una clausola `WHERE`, e apparirebbe in questo modo:

SELECT student_surname
FROM student_grades
WHERE COUNT(grade) > 1

Ma, come puoi vedere, viene restituito un <span style="color:red">errore</span> che indica che **non è possibile utilizzare funzioni di aggregazione** all'interno di una clausola `WHERE`. In questi casi è necessario utilizzare la clausola `HAVING`.

Supponiamo sia necessario **recuperare i reparti** in cui lo **stipendio medio** dei dipendenti è **inferiore a $70.000 all'anno**.
Per ottenere questo risultato, occorre utilizzare una funzione di aggregazione e la clausola `HAVING`:

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

Il risultato è un solo dipartimento in risposta utilizzando la clausola `HAVING`, dove viene impostata una **condizione per la colonna** utilizzata per il raggruppamento.



**Per utilizzare l'aggregazione dei dati** all'interno della clausola `HAVING`, è necessario avere **un raggruppamento dei dati nella query**. Come nella query sopra, abbiamo raggruppato i dati per la colonna `department`.

Nota

Di seguito è riportata la sintassi più generalizzata della clausola `HAVING` e quando è meglio utilizzarla:

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

-- This will cause an error
```

Ecco una breve panoramica della **differenza principale** tra le clausole `WHERE` e `HAVING` e quando utilizzare ciascuna di esse:

1. La clausola `WHERE` viene utilizzata **prima** dell'aggregazione dei dati, mentre la clausola `HAVING` viene utilizzata **dopo** l'aggregazione dei dati;
2. La clausola `WHERE` viene scritta **prima** di `GROUP BY`, mentre la clausola `HAVING` viene scritta **dopo** `GROUP BY`.

Queste sono le **due principali differenze** da ricordare per un uso corretto della clausola `HAVING`. Ora, torniamo al compito assegnato dalla scuola.

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

Questo corso è ideale per chi possiede già una conoscenza di base di SQL e desidera approfondire concetti più avanzati per creare query più potenti. Durante il corso, acquisirai familiarità con il raggruppamento dei dati e il filtraggio dei dati raggruppati. Imparerai inoltre a lavorare con più tabelle contemporaneamente, inclusa la loro combinazione. Esplorerai inoltre i diversi tipi di join tra tabelle e come applicarli nella pratica.

In questa sezione verrà illustrato come raggruppare e gestire i dati in modo efficace. Verrà introdotto l'operatore GROUP BY per il raggruppamento dei dati. Inoltre, verrà spiegato come filtrare i dati raggruppati utilizzando l'operatore HAVING.

Imparerai le sottoquery annidate, come crearle e come utilizzarle in modo efficace.

Qui imparerai come combinare più tabelle, permettendoti di lavorare con una tabella unificata e semplificare la creazione delle query.

Apprendi i fondamenti del Data Definition Language (DDL) e del Data Manipulation Language (DML) in SQL, inclusi la creazione, la modifica e l'eliminazione di oggetti di database, nonché l'inserimento, l'aggiornamento e l'eliminazione di dati all'interno delle tabelle.

Clausola Having

Istruzioni sintetiche

Soluzione