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

Het informatiesysteem van de school wordt herzien om gegevensconsistentie en nauwkeurigheid te waarborgen.
Als onderdeel van deze herziening is een nieuwe data-analysetaak toegewezen.

Tijdens routinematige controles werd ontdekt dat sommige leerlingendossiers meer dan één cijfervermelding bevatten, terwijl het systeem is ontworpen om slechts één cijfer per leerling op te slaan.

Jouw taak is om dergelijke gevallen te identificeren voor verder intern onderzoek.

Denk na over **hoe je dit kunt doen**. Je zou kunnen beginnen met het overwegen dat je dit kunt doen met een `WHERE`-clausule, en het zou er ongeveer zo uitzien:

SELECT student_surname
FROM student_grades
WHERE COUNT(grade) > 1

Maar, zoals je kunt zien, krijgen we een <span style="color:red">foutmelding</span> die aangeeft dat **je geen aggregatiefuncties kunt gebruiken** binnen een `WHERE`-clausule. Hiervoor heb je de `HAVING`-clausule nodig.

Stel dat je **de afdelingen wilt ophalen** waar het **gemiddelde** salaris van werknemers **lager is dan $70.000 per jaar**.
Om dit te bereiken, moeten we een aggregatiefunctie en de `HAVING`-clausule gebruiken:

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

Het resultaat is één afdeling als antwoord met behulp van de `HAVING`-clausule, waarbij een **voorwaarde wordt ingesteld voor de kolom** die wordt gebruikt voor groepering.



**Om gegevensaggregatie te gebruiken** binnen de `HAVING`-clausule, moet er **gegevensgroepering in onze query** zijn. Zoals in de bovenstaande query hebben we de gegevens gegroepeerd op de kolom `department`.

Opmerking

Hier volgt een meer algemene syntaxis van de `HAVING`-clausule en wanneer deze het beste kan worden gebruikt:

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

-- This will cause an error
```

Hier volgt een kort overzicht van het **belangrijkste verschil** tussen de `WHERE`- en `HAVING`-clausules en wanneer je welke gebruikt:

1. De `WHERE`-clausule wordt gebruikt **voor** data-aggregatie, terwijl de `HAVING`-clausule wordt gebruikt **na** data-aggregatie;
2. De `WHERE`-clausule wordt **voor** `GROUP BY` geschreven, terwijl de `HAVING`-clausule **na** `GROUP BY` wordt geschreven.

Dit zijn de **twee belangrijkste verschillen** die je moet onthouden voor het succesvol gebruiken van de `HAVING`-clausule. Ga nu terug naar de opdracht die we van de school hebben gekregen.

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

Deze cursus is ideaal voor wie al een basiskennis van SQL heeft en zich wil verdiepen in geavanceerdere concepten om krachtigere query's te maken. Tijdens de cursus maak je kennis met het groeperen van gegevens en het filteren van gegroepeerde data. Je leert ook hoe je met meerdere tabellen tegelijk werkt, inclusief het combineren ervan. Daarnaast verken je verschillende soorten joins tussen tabellen en hoe je deze in de praktijk toepast.

In deze sectie leert u hoe u gegevens effectief kunt groeperen en beheren. We introduceren de GROUP BY-operator voor het groeperen van gegevens. Daarnaast leert u hoe u gegroepeerde gegevens kunt filteren met behulp van de HAVING-operator.

U leert over geneste subquery's, hoe u deze maakt en hoe u ze effectief gebruikt.

Hier leert u hoe u meerdere tabellen kunt combineren, zodat u met een samengestelde tabel kunt werken en het opstellen van query's kunt vereenvoudigen.

Leer de basisprincipes van Data Definition Language (DDL) en Data Manipulation Language (DML) in SQL, inclusief het aanmaken, wijzigen en verwijderen van databaseobjecten, evenals het invoegen, bijwerken en verwijderen van gegevens binnen tabellen.

HAVING-Clausule

Korte instructies

Oplossing