Vergleich von WHERE und HAVING: Ausführungsreihenfolge und Beispiele

Lass uns nochmal durchgehen, wie die Ausführungsreihenfolge in SQL aussieht und womit WHERE und HAVING jeweils arbeiten können oder eben nicht. Das ist ein wichtiger Punkt, auf dem viele Feinheiten bei SQL-Queries aufbauen. Du solltest das wirklich gut verstehen.

Was ist also der Unterschied zwischen WHERE und HAVING, wann benutzt man das eine, wann das andere und wie hängen sie zusammen? Das hilft dir, nicht in der Logik der Abfragen durcheinander zu kommen und Daten effektiv zu filtern. Lass uns unser Wissen zu WHERE und HAVING zusammenfassen.

Was ist WHERE?

WHERE ist eine Bedingung, die verwendet wird, um Zeilen vor der Gruppierung oder Anwendung von Aggregatfunktionen zu filtern. Das heißt, zuerst werden aus der Tabelle die Zeilen ausgewählt, die den Kriterien entsprechen, und erst danach wird auf den verbleibenden Daten gruppiert.

👉 Stell dir vor, du sammelst Obst auf dem Markt. WHERE ist der Filter, mit dem du schon vorher die schlechten Äpfel aussortierst, bevor du sie nach Größe oder Farbe sortierst.

Beispiel:

SELECT *
FROM students
WHERE age > 18;

Diese Abfrage wählt alle Studenten über 18 Jahre bevor irgendwelche anderen Operationen ausgeführt werden.

Was ist HAVING?

HAVING ist ein Filter, der nach der Gruppierung der Daten (GROUP BY) angewendet wird. Damit kannst du Bedingungen auf die gruppierten Daten anwenden, zum Beispiel nur die Gruppen behalten, in denen der Durchschnitt der Noten über 80 liegt.

👉 Wieder das Beispiel mit den Äpfeln. HAVING ist der Filter, den du benutzt, nachdem du die Äpfel schon in Körbe (Gruppen) sortiert hast. Jetzt interessieren dich zum Beispiel nur die Körbe (Gruppen), in denen mehr als zehn Äpfel liegen.

Beispiel:

SELECT korb, COUNT(*)
FROM aepfel
GROUP BY korb
HAVING COUNT(*) > 10;

Diese Abfrage wählt nur die Körbe aus, in denen mehr als 10 Äpfel liegen.

Hauptunterschiede:

Reihenfolge von WHERE, GROUP BY und HAVING

Um besser zu verstehen, wie WHERE und HAVING funktionieren, schauen wir uns die Ausführungsreihenfolge von SQL-Queries an:

1. Zuerst wird FROM ausgeführt, die Zeilen werden aus der Tabelle ausgewählt.
2. Dann wird WHERE angewendet, es werden nur die Zeilen gefiltert, die die Bedingungen erfüllen.
3. Danach erfolgt die Gruppierung mit GROUP BY. Wir bekommen eine neue Tabelle mit Gruppendaten.
4. HAVING wird angewendet, Gruppen werden gefiltert, die die Bedingungen erfüllen.
5. Am Ende werden die Ergebnisse mit SELECT ausgewählt.

Schematisch sieht das so aus:

1. FROM → 2. WHERE → 3. GROUP BY → 4. HAVING → 5. SELECT

Beispiel:

SELECT department, AVG(age) AS avg_age
FROM students
WHERE age > 18
GROUP BY department
HAVING AVG(age) > 20;

Hier passiert Folgendes:

1. In der Tabelle students werden die Zeilen ausgewählt, wo age > 18 (WHERE wird benutzt).
2. Die übrigen Zeilen werden nach department gruppiert.
3. Für jede Gruppe wird das Durchschnittsalter berechnet.
4. Gruppen, in denen das Durchschnittsalter kleiner oder gleich 20 ist, werden durch HAVING ausgeschlossen.
5. Die Ergebnisse werden ausgegeben.

Beispiele für die kombinierte Verwendung

Beispiel 1: Filtern vor und nach der Gruppierung

Bedingung: Finde die Fachbereiche, in denen es mehr als 5 Studenten gibt, wobei nur Studenten über 18 Jahre berücksichtigt werden.

Ursprungstabelle students

Abfrage:

SELECT department, COUNT(*) AS student_count
FROM students
WHERE age > 18
GROUP BY department
HAVING COUNT(*) > 5;

Ergebnis: -- Ergebnis der Abfrage

Erklärung:

1. Zuerst entfernen wir die Zeilen, wo age <= 18 (WHERE-Bedingung).
2. Wir gruppieren die Daten nach Fachbereichen (GROUP BY department).
3. Wir berechnen die Anzahl der Studenten in jeder Gruppe.
4. Wir entfernen Gruppen, in denen es weniger oder gleich 5 Studenten gibt (HAVING COUNT(*) > 5).

Beispiel 2: Fehler bei der Verwendung von WHERE statt HAVING

Bedingung: Finde Fachbereiche, in denen das Durchschnittsalter über 22 Jahre liegt.

Falsche Abfrage:

SELECT department, AVG(age) AS avg_age
FROM students
WHERE AVG(age) > 22
GROUP BY department;

Fehler: SQL erlaubt keine Aggregatfunktionen wie AVG in WHERE, weil die Aggregate zu diesem Zeitpunkt noch nicht berechnet wurden.

Korrekte Abfrage:

SELECT department, AVG(age) AS avg_age
FROM students
GROUP BY department
HAVING AVG(age) > 22;

Hier wird die Bedingung AVG(age) > 22 nach der Gruppierung angewendet.

Praxistipps

Wenn du Zeilen filtern willst, benutze WHERE. Beispiel: Finde alle Mitarbeiter mit einem Gehalt über 5000.

SELECT *
FROM employees
WHERE salary > 5000;

Wenn du Gruppen filtern willst, benutze HAVING. Beispiel: Finde Abteilungen mit einem Gesamtgehalt über 100.000.

SELECT department, SUM(salary) AS total_salary
FROM employees
GROUP BY department
HAVING SUM(salary) > 100000;

Kombiniere WHERE und HAVING für komplexe Bedingungen.

Beispiel: Finde Länder mit mehr als 10 Millionen Einwohnern, wobei nur Städte mit mehr als 1 Million Einwohnern berücksichtigt werden.

SELECT country, SUM(population) AS total_population
FROM cities
WHERE population > 1000000
GROUP BY country
HAVING SUM(population) > 10000000;

Typische Fehler und wie du sie löst

Einer der häufigsten Fehler ist die Verwechslung von WHERE und HAVING. Zum Beispiel der Versuch, eine Aggregatfunktion in WHERE zu verwenden:

SELECT department, COUNT(*)
FROM students
WHERE COUNT(*) > 10
GROUP BY department;

So eine Abfrage führt zu einem Fehler, weil Aggregatberechnungen im WHERE-Schritt noch nicht verfügbar sind. Der richtige Weg ist, HAVING zu verwenden:

SELECT department, COUNT(*)
FROM students
GROUP BY department
HAVING COUNT(*) > 10;

Ein weiterer Fehler ist die falsche Bedingung im WHERE. Zum Beispiel:

SELECT department, AVG(age) AS avg_age
FROM students
WHERE avg_age > 20
GROUP BY department;

Hier ist die Bedingung avg_age > 20 falsch, weil avg_age noch nicht berechnet wurde. Die Lösung: Diese Bedingung in HAVING verschieben:

SELECT department, AVG(age) AS avg_age
FROM students
GROUP BY department
HAVING AVG(age) > 20;

Ich hoffe, du hast jetzt ein klares Verständnis davon, was WHERE und HAVING unterscheidet, wie du sie richtig einsetzt und wie du typische Fehler vermeidest. Dieses Wissen brauchst du beim Erstellen von komplexen Reports, beim Filtern von Daten für Analysen und beim Optimieren von Abfragen. Also für mehr als die Hälfte aller echten SQL-Queries, die du schreiben wirst :)