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

Skoleinformationssystemet gennemgås for at sikre datakonsistens og nøjagtighed.
Som en del af denne gennemgang er der blevet tildelt en ny dataanalyseringsopgave.

Under rutinetjek blev det opdaget, at nogle elevposter indeholder mere end én karakterregistrering, selvom systemet er designet til kun at gemme én karakter pr. elev.

Din opgave er at hjælpe med at identificere sådanne tilfælde til yderligere intern gennemgang.

Overvej **hvordan du kan gøre dette**. Du kan starte med at tænke på, at du kan gøre dette ved hjælp af en `WHERE`-klausul, og det kunne se sådan ud:

SELECT student_surname
FROM student_grades
WHERE COUNT(grade) > 1

Men som du kan se, får vi en <span style="color:red">fejl</span>, der angiver, at **du ikke kan bruge aggregeringsfunktioner** i en `WHERE`-klausul. Dette er hvor du skal bruge `HAVING`-klausulen.

Antag, at du skal **hente de afdelinger**, hvor medarbejdernes **gennemsnitlige** løn er **under $70.000 om året**.
For at opnå dette skal vi bruge en aggregeringsfunktion og `HAVING`-klausulen:

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

Resultatet er én afdeling i svaret ved brug af `HAVING`-klausulen, hvor en **betingelse er angivet for kolonnen**, som bruges til gruppering.



**For at bruge dataaggregering** inden for `HAVING`-klausulen, skal vi have **datagruppering i vores forespørgsel**. Som i forespørgslen ovenfor grupperede vi dataene efter kolonnen `department`.

Bemærk

Her er en mere generaliseret syntaks for `HAVING`-klausulen og hvornår det er bedst at bruge den:

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

-- This will cause an error
```

Her er et kort overblik over **hovedforskellen** mellem `WHERE`- og `HAVING`-klausulerne, samt hvornår de skal bruges:

1. `WHERE`-klausulen bruges **før** dataaggregering, mens `HAVING`-klausulen bruges **efter** dataaggregering;
2. `WHERE`-klausulen skrives **før** `GROUP BY`, mens `HAVING`-klausulen skrives **efter** `GROUP BY`.

Dette er de **to vigtigste forskelle**, du skal huske for at bruge `HAVING`-klausulen korrekt. Gå nu tilbage til opgaven, som skolen har givet os.

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

Dette kursus er ideelt for dem, der allerede har et grundlæggende kendskab til SQL og ønsker at fordybe sig i mere avancerede koncepter for at udforme mere kraftfulde forespørgsler. Gennem kurset vil du blive fortrolig med gruppering af data og filtrering af grupperede data. Du vil også lære at arbejde med flere tabeller samtidigt, herunder hvordan de kombineres. Derudover vil du udforske forskellige typer af tabel-joins og hvordan de anvendes i praksis.

I dette afsnit lærer du, hvordan du grupperer og håndterer data effektivt. Vi introducerer GROUP BY-operatoren til gruppering af data. Derudover lærer du, hvordan du filtrerer grupperede data ved hjælp af HAVING-operatoren.

Du vil lære om indlejrede underforespørgsler, hvordan de oprettes, og hvordan de anvendes effektivt.

Her vil du lære, hvordan man kombinerer flere tabeller, hvilket gør det muligt at arbejde med en samlet tabel og forenkle oprettelsen af forespørgsler.

Lær det grundlæggende om Data Definition Language (DDL) og Data Manipulation Language (DML) i SQL, herunder hvordan man opretter, ændrer og sletter databaseobjekter samt indsætter, opdaterer og sletter data i tabeller.

HAVING-Klausul

Korte instruktioner

Løsning