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

Informationssystemet för skolan granskas för att säkerställa datakonsistens och noggrannhet.
Som en del av denna granskning har en ny dataanalysuppgift tilldelats.

Vid rutinmässiga kontroller upptäcktes att vissa studentposter innehåller mer än en betygspost, trots att systemet är utformat för att lagra endast ett betyg per student.

Din uppgift är att hjälpa till att identifiera sådana fall för vidare intern granskning.

Fundera på **hur du kan göra detta**. Du kan börja med att överväga att du kan göra detta med en `WHERE`-sats, och det skulle se ut ungefär så här:

SELECT student_surname
FROM student_grades
WHERE COUNT(grade) > 1

Men, som du kan se, får vi ett <span style="color:red">felmeddelande</span> som indikerar att **du inte kan använda aggregeringsfunktioner** i en `WHERE`-sats. Det är här du behöver använda `HAVING`-satsen.

Anta att du behöver **hämta de avdelningar** där de anställdas **genomsnittliga** lön är **under $70 000 per år**.
För att uppnå detta behöver vi använda en aggregeringsfunktion och `HAVING`-satsen:

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

Resultatet är en avdelning i svaret med hjälp av `HAVING`-satsen, där ett **villkor anges för kolumnen** som används för gruppering.



**För att använda dataaggregering** inom `HAVING`-satsen måste vi ha **datagruppering i vår fråga**. Som i frågan ovan grupperade vi data efter kolumnen `department`.

Notering

Här är en mer generell syntax för `HAVING`-satsen och när det är bäst att använda den:

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

-- This will cause an error
```

Här är en kort översikt över **huvudskillnaden** mellan `WHERE`- och `HAVING`-satser samt när du ska använda var och en av dem:

1. `WHERE`-satsen används **innan** dataaggregering, medan `HAVING`-satsen används **efter** dataaggregering;
2. `WHERE`-satsen skrivs **före** `GROUP BY`, medan `HAVING`-satsen skrivs **efter** `GROUP BY`.

Detta är de **två viktigaste skillnaderna** du behöver komma ihåg för att använda `HAVING`-satsen framgångsrikt. Återgå nu till uppgiften vi fick av skolan.

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

Denna kurs är perfekt för dig som redan har grundläggande kunskaper i SQL och vill fördjupa dig i mer avancerade koncept för att skapa kraftfullare frågor. Under kursens gång kommer du att bekanta dig med gruppering av data och filtrering av grupperad data. Du kommer även att lära dig arbeta med flera tabeller samtidigt, inklusive hur du kombinerar dem. Dessutom kommer du att utforska olika typer av tabelljoiner och hur de tillämpas i praktiken.

I det här avsnittet kommer du att lära dig hur du grupperar och hanterar data effektivt. Vi introducerar operatorn GROUP BY för gruppering av data. Dessutom kommer du att lära dig hur du filtrerar grupperad data med hjälp av operatorn HAVING.

Du kommer att lära dig om nästlade underfrågor, hur de skapas och hur de används effektivt.

Här kommer du att lära dig hur man kombinerar flera tabeller, vilket gör det möjligt att arbeta med en enhetlig tabell och förenkla skapandet av frågor.

Lär dig grunderna i Data Definition Language (DDL) och Data Manipulation Language (DML) i SQL, inklusive hur man skapar, ändrar och tar bort databasobjekt samt hur man infogar, uppdaterar och tar bort data i tabeller.

HAVING-sats

Kortfattade instruktioner

Lösning