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

Skoleinformasjonssystemet gjennomgås for å sikre datakonsistens og nøyaktighet.
Som en del av denne gjennomgangen er det tildelt en ny dataanalyseoppgave.

Under rutinemessige kontroller ble det oppdaget at noen elevregistre inneholder mer enn én karakteroppføring, selv om systemet er utformet for å lagre kun én karakter per elev.

Din oppgave er å hjelpe til med å identifisere slike tilfeller for videre intern gjennomgang.

Tenk på **hvordan du kan gjøre dette**. Du kan starte med å vurdere at dette kan gjøres ved å bruke en `WHERE`-setning, og det vil se omtrent slik ut:

SELECT student_surname
FROM student_grades
WHERE COUNT(grade) > 1

Men, som du kan se, får vi en <span style="color:red">feilmelding</span> som indikerer at **du ikke kan bruke aggregeringsfunksjoner** inne i en `WHERE`-setning. Dette er grunnen til at du trenger `HAVING`-setningen.

Anta at du må **hente avdelinger** der de ansattes **gjennomsnittlige** lønn er **under $70 000 per år**.
For å oppnå dette må vi bruke en aggregeringsfunksjon og `HAVING`-setningen:

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

Resultatet er én avdeling i svaret ved bruk av `HAVING`-klausulen, der en **betingelse settes for kolonnen** som brukes til gruppering.



**For å bruke dataaggregering** i `HAVING`-klausulen, må vi ha **datagruppering i spørringen vår**. Som i spørringen ovenfor, grupperte vi dataene etter kolonnen `department`.

Merk

Her er en mer generell syntaks for `HAVING`-klausulen og når det er best å bruke den:

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

-- This will cause an error
```

Her er en kort oversikt over **hovedforskjellen** mellom `WHERE`- og `HAVING`-setninger, og når du bør bruke hver av dem:

1. `WHERE`-setningen brukes **før** dataaggregering, mens `HAVING`-setningen brukes **etter** dataaggregering;
2. `WHERE`-setningen skrives **før** `GROUP BY`, mens `HAVING`-setningen skrives **etter** `GROUP BY`.

Dette er de **to viktigste forskjellene** du må huske for å bruke `HAVING`-setningen riktig. Nå kan du gå tilbake til oppgaven vi fikk av skolen.

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 kurset passer for deg som allerede har grunnleggende kunnskap om SQL og ønsker å fordype deg i mer avanserte konsepter for å lage kraftigere spørringer. Gjennom kurset blir du kjent med gruppering av data og filtrering av grupperte data. Du lærer også hvordan du arbeider med flere tabeller samtidig, inkludert hvordan du kombinerer dem. I tillegg utforsker du ulike typer tabellkoblinger og hvordan disse kan brukes i praksis.

I denne delen vil du lære hvordan du grupperer og håndterer data effektivt. Vi introduserer GROUP BY-operatøren for gruppering av data. Du vil også lære hvordan du filtrerer grupperte data ved hjelp av HAVING-operatøren.

Du vil lære om nestede underforespørsler, hvordan de opprettes, og hvordan de brukes effektivt.

Her vil du lære hvordan du kan kombinere flere tabeller, slik at du kan arbeide med en samlet tabell og forenkle opprettelsen av spørringer.

Lær det grunnleggende om Data Definition Language (DDL) og Data Manipulation Language (DML) i SQL, inkludert hvordan man oppretter, endrer og sletter databaseobjekter, samt hvordan man setter inn, oppdaterer og sletter data i tabeller.

HAVING-Setning

Korte instruksjoner

Løsning