7. Aggregation und Gruppierung

Aggregation und Gruppierung in SQL

Während das Abrufen einzelner Zeilen wesentlich ist, liegt die wahre Stärke von SQL in seiner Fähigkeit, Rohdaten in aussagekräftige Erkenntnisse zu verwandeln. Im professionellen Umfeld müssen Sie selten jede einzelne Transaktion oder jeden Schülerdatensatz sehen; stattdessen brauchen Sie Antworten auf übergeordnete Fragen:

Was ist die Durchschnittsnote in einer Klasse?
Wie viele Schüler sind in jedem Fach angemeldet?
Wie hoch war der Gesamtumsatz im letzten Monat?

Hier kommen Aggregatfunktionen und die GROUP BY-Klausel ins Spiel. Aggregation erlaubt es Ihnen, mehrere Datenzeilen zu einem einzigen Zusammenfassungswert “zusammenzufalten”, während die Gruppierung es ermöglicht, Ihre Daten in logische Behälter (Buckets) zu unterteilen, bevor diese Berechnungen durchgeführt werden. Die Beherrschung dieser Werkzeuge macht aus einem Datenbankbenutzer einen Datenanalysten und erlaubt es Ihnen, Muster und Trends in Ihren relationalen Daten zu erkennen.

Daten gruppieren (`GROUP BY`)

Die GROUP BY-Klausel wird verwendet, um identische Daten in Gruppen anzuordnen. Dieses “Zusammenfalten” von Zeilen ist die Voraussetzung dafür, Berechnungen auf bestimmten Teilmengen Ihrer Daten durchzuführen (z. B. die Durchschnittsnote pro Klasse zu berechnen statt für die gesamte Schule).

Wie es funktioniert: Das Bucket-Konzept

Stellen Sie sich Ihre Tabelle students vor. Wenn Sie nach der Spalte class gruppieren, erstellt SQL einen “Bucket” für jeden eindeutigen Klassennamen (4A, 4B usw.). Jede Zeile, die zu “4A” gehört, wird in den 4A-Bucket gelegt.

Die goldene Regel der Gruppierung:

Bei Verwendung von GROUP BY muss jede in Ihrer SELECT-Anweisung aufgeführte Spalte eine von zwei Bedingungen erfüllen:

Sie ist in der GROUP BY-Klausel enthalten.
Sie ist in eine Aggregatfunktion eingeschlossen (wie SUM oder COUNT).

SELECT class, COUNT(student_id)
FROM students
GROUP BY class;

Die folgende Abfrage ist nicht gültig, weil first_name weder gruppiert noch aggregiert ist. Die Datenbank wüsste nicht, welchen first_name sie für die gesamte Klasse anzeigen soll, da es in jeder Klasse mehrere Schüler gibt.

SELECT class, first_name
FROM students
GROUP BY class;

Gruppieren nach mehr als einer Spalte

Bisher haben wir nach einer einzelnen Spalte gruppiert. Sie können auch mehrere Spalten in der GROUP BY-Klausel auflisten. Entscheidend ist zu verstehen, was zu einem Bucket wird: SQL erstellt einen Bucket für jede eindeutige Kombination von Werten über alle aufgeführten Spalten hinweg - nicht einen Bucket pro Spalte.

Denken Sie an die Kisten zurück. Bei GROUP BY class war die Beschriftung auf jeder Kiste nur der Klassenname. Bei GROUP BY class, subject wird die Beschriftung auf jeder Kiste zu einem Paar: (class, subject). Zwei Zeilen landen nur dann in derselben Kiste, wenn sie in beiden Werten übereinstimmen.

Stellen Sie sich eine Tabelle grades wie diese vor:

subject	score
Databases	1
Databases	1
Databases	2
Networking	1
Networking	3
Networking	3

Nun zählen wir, wie oft jede Note pro Fach vergeben wurde:

SELECT subject, score, COUNT(*) AS how_many
FROM grades
GROUP BY subject, score;

SQL bildet einen Bucket pro eindeutiger (subject, score)-Kombination und zählt die Zeilen in jedem:

subject	score	how_many
Databases	1	2
Databases	2	1
Networking	1	1
Networking	3	2

Was Sie beachten sollten:

“Databases” für sich allein ist kein Bucket mehr. (Databases, 1) und (Databases, 2) sind zwei getrennte Buckets, weil die zweite Gruppierungsspalte sie auseinandertrennt.
Je mehr Spalten Sie zu GROUP BY hinzufügen, desto mehr Buckets erhalten Sie - und desto kleiner wird jeder Bucket (feinere Granularität).
Die Reihenfolge der Spalten in GROUP BY ändert nicht, welche Buckets gebildet werden: GROUP BY subject, score und GROUP BY score, subject erzeugen dieselben Gruppen. (Sie ist nur für die angezeigte Reihenfolge relevant, wenn Sie ein ORDER BY hinzufügen.)
Die goldene Regel gilt weiterhin: Jede Spalte in der SELECT-Liste (subject und score) ist entweder in GROUP BY aufgeführt oder in eine Aggregatfunktion eingeschlossen.

Aggregatfunktionen

Aggregatfunktionen führen eine Berechnung auf einer Menge von Werten durch und geben einen einzigen Wert zurück. Sie werden fast immer zusammen mit GROUP BY verwendet.

Funktion	Beschreibung	Beispiel
`COUNT()`	Gibt die Anzahl der Zeilen zurück.	`COUNT(*)` zählt alle Zeilen; `COUNT(col)` zählt Nicht-NULL-Werte.
`SUM()`	Berechnet die Gesamtsumme einer numerischen Spalte.	`SUM(score)`
`AVG()`	Berechnet das arithmetische Mittel (Durchschnitt).	`AVG(score)`
`MIN()`	Findet den kleinsten Wert in einer Menge.	`MIN(birth_date)` (Der älteste Schüler)
`MAX()`	Findet den größten Wert in einer Menge.	`MAX(birth_date)` (Der jüngste Schüler)

Beispiel - Analyse der Klassenleistung:

SELECT
    subject,
    AVG(score) AS average_grade,
    COUNT(*) AS total_exams
FROM grades
GROUP BY subject;

Filtern: `WHERE` vs. `HAVING`

Einer der häufigsten Verwirrungspunkte ist die Frage, wann WHERE und wann HAVING zu verwenden ist. Beide dienen dem Filtern, aber sie wirken in unterschiedlichen Phasen der Abfrage.

Die `WHERE`-Klausel

Die WHERE-Klausel filtert einzelne Zeilen bevor irgendeine Gruppierung stattfindet. Wenn eine Zeile die WHERE-Bedingung nicht erfüllt, gelangt sie gar nicht erst in einen “Bucket”.

Die `HAVING`-Klausel

Die HAVING-Klausel filtert Gruppen nachdem die GROUP BY- und Aggregatberechnungen durchgeführt wurden. Sie verwenden HAVING, wenn Sie anhand eines Aggregatergebnisses filtern möchten (z. B. “zeige nur Klassen mit mehr als 20 Schülern”).

Vergleichsbeispiel:

Im folgenden Beispiel filtert WHERE vor der Gruppierung Schüler heraus, die vor 2010 geboren wurden, während HAVING nach der Gruppierung Gruppen (Klassen) herausfiltert, die 2 oder weniger Schüler haben.

SELECT class, COUNT(*) as student_count
FROM students
WHERE birth_date > '2010-01-01'
GROUP BY class
HAVING COUNT(*) > 2;

Die logische Ausführungsreihenfolge

Um zu verstehen, warum HAVING nach GROUP BY kommt, hilft ein Blick auf die Reihenfolge, in der die Datenbank Ihren Befehl tatsächlich verarbeitet. Auch wenn wir SELECT zuerst schreiben, führt die Datenbank es erst viel später aus:

FROM & JOIN: Die Datenbank sammelt alle Rohdaten.
WHERE: Einzelne Zeilen werden herausgefiltert.
GROUP BY: Die verbleibenden Zeilen werden in Buckets organisiert.
HAVING: Ganze Buckets (Gruppen) werden anhand von Aggregatwerten herausgefiltert.
SELECT: Die endgültigen Spalten und Berechnungen werden für die Anzeige vorbereitet.
ORDER BY: Die endgültige Ergebnismenge wird sortiert.

Zusammenfassung: Aggregation und Gruppierung

In relationalen Datenbanken erfordert die Datenanalyse oft den Wechsel von der Betrachtung einzelner Datensätze hin zur Erzeugung übergeordneter Zusammenfassungen. Dieses Kapitel hat behandelt, wie man Aggregatfunktionen verwendet, um Berechnungen durchzuführen, und die GROUP BY-Klausel, um Daten in logische Teilmengen zu organisieren.

1. Das Kernkonzept der Gruppierung

Gruppierung erlaubt es Ihnen, mehrere Zeilen auf Basis gemeinsamer Werte in bestimmten Spalten zu einzelnen Zusammenfassungszeilen “zusammenzufalten”.

Die Bucket-Logik: Wenn Sie nach einer Spalte gruppieren, legt SQL alle Datensätze mit demselben Wert in einen einzigen “Bucket” zur Berechnung.
Die goldene Regel: Jede Spalte in Ihrer SELECT-Liste muss entweder Teil der GROUP BY-Klausel sein oder in eine Aggregatfunktion eingeschlossen sein. Das stellt sicher, dass keine Mehrdeutigkeit darüber besteht, welcher Datenpunkt für eine Gruppe angezeigt werden soll.

2. Wesentliche Aggregatfunktionen

Diese Funktionen führen Berechnungen auf einer Menge von Werten innerhalb einer Gruppe (oder der gesamten Tabelle) durch, um einen einzigen informativen Wert zurückzugeben.

Funktion	Zweck	Häufiger Anwendungsfall
`COUNT()`	Zählt die Anzahl der Elemente.	Schüler pro Klasse oder Gesamtzahl der Bestellungen zählen.
`SUM()`	Addiert numerische Werte.	Gesamtumsatz oder Gesamtpunkte berechnen.
`AVG()`	Findet das arithmetische Mittel.	Durchschnittliche Testergebnisse oder Preise bestimmen.
`MIN()`	Findet den niedrigsten Wert.	Die niedrigste Note oder das früheste Datum identifizieren.
`MAX()`	Findet den höchsten Wert.	Die beste Punktzahl oder den neuesten Eintrag identifizieren.

3. Filtern: `WHERE` vs. `HAVING`

Das Verständnis des Zeitpunkts dieser beiden Klauseln ist entscheidend für eine korrekte Datenanalyse.

WHERE (Vorfilter): Wirkt auf einzelne Zeilen vor der Gruppierung. Verwenden Sie es, um bestimmte Daten von der Berechnung gänzlich auszuschließen (z. B. “Inaktive Benutzer ausschließen”).
HAVING (Nachfilter): Wirkt auf Gruppen nach der Aggregation. Verwenden Sie es, um anhand der Ergebnisse von Funktionen wie SUM oder COUNT zu filtern (z. B. “Nur Abteilungen mit mehr als 10 Mitarbeitern anzeigen”).

4. Logische Ausführungsreihenfolge

Um erfolgreiche komplexe Abfragen zu schreiben, müssen Sie sich merken, dass die Datenbank die Klauseln nicht in der Reihenfolge verarbeitet, in der sie geschrieben werden. Der Ausführungsablauf ist:

FROM / JOIN (Daten sammeln)
WHERE (Zeilen filtern)
GROUP BY (in Buckets organisieren)
HAVING (Buckets filtern)
SELECT (Ergebnisse berechnen)
ORDER BY (endgültige Liste sortieren)

Lernergebnisse: Was Sie können sollten

Berechnen: Funktionen wie SUM, AVG und COUNT verwenden, um Kennzahlen aus Rohdaten zu gewinnen.
Organisieren: GROUP BY anwenden, um Berichte zu erzeugen, die nach bestimmten Attributen kategorisiert sind (z. B. nach Datum, Kategorie oder Abteilung).
Unterscheiden: Korrekt zwischen WHERE und HAVING wählen, je nachdem, ob der Filter auf Rohzeilen oder aggregierte Ergebnisse zutrifft.
Analysieren: Die Gültigkeit einer Abfrage anhand der “goldenen Regel” der Gruppierung bestimmen.
Reihenfolge beachten: Komplexe SQL-Anweisungen entsprechend der logischen Ausführungsreihenfolge strukturieren, um Syntax- und Logikfehler zu vermeiden.