Typische Fehler beim Arbeiten mit Aggregaten

Jetzt ist es Zeit, tiefer in die typischen Fehler einzutauchen, die bei der Verwendung dieser Funktionen passieren. Selbst die erfahrensten SQL-Pros treten manchmal auf die gleichen Fallen, und unser Ziel ist es, diese Fallen zu erkennen und sie gekonnt zu umgehen.

Hast du schon mal einen Query geschrieben und plötzlich kam eine mysteriöse Fehlermeldung wie "column must appear in the GROUP BY clause or be used in an aggregate function"? Oder vielleicht sah das Ergebnis deines Queries irgendwie komisch aus und du hattest keinen Plan, warum? Das ist nur die Spitze des Eisbergs der typischen Fehler mit Aggregatfunktionen. Diese Vorlesung ist dein Survival-Guide im Meer der Fehler und Missverständnisse.

Fehler 1: Verwendung einer nicht aggregierten Spalte außerhalb von GROUP BY

Problem

Du hast einen Query geschrieben, der aggregierte Daten zurückgibt, aber unterwegs hast du eine Spalte hinzugefügt, die nicht Teil der Gruppierung ist und nicht in einer Aggregatfunktion steckt. Zum Beispiel:

SELECT department, gehalt, SUM(gehalt)
FROM mitarbeiter
GROUP BY department;

PostgreSQL sagt dir sofort:

ERROR: column "mitarbeiter.gehalt" must appear in the GROUP BY clause or be used in an aggregate function

Warum passiert das?

Wenn du GROUP BY benutzt, fasst PostgreSQL die Zeilen nach den angegebenen Spalten zusammen. Aber wenn du noch eine Spalte dazupackst (hier gehalt), weiß PostgreSQL nicht, was es damit machen soll. Soll es nur ein Gehalt nehmen, den Durchschnitt oder was ganz anderes?

Wie löst man das? Es gibt zwei Wege:

1. Stell sicher, dass alle nicht aggregierten Spalten im GROUP BY stehen:

SELECT department, gehalt
FROM mitarbeiter
GROUP BY department, gehalt;

2. Oder pack die Spalte in eine Aggregatfunktion, wenn das Sinn macht:

SELECT department, AVG(gehalt) AS avg_gehalt
FROM mitarbeiter
GROUP BY department;

Tipp: Wenn PostgreSQL bei GROUP BY meckert, frag dich: "Brauche ich diese Spalte wirklich im Query? Und wenn ja, welche Rolle spielt sie genau?"

Fehler 2: Falscher Umgang mit COUNT() und NULL

Problem: Du willst wissen, wie viele Mitarbeiter ihren Bonus angegeben haben, und schreibst:

SELECT COUNT(bonus) AS bonus_anzahl
FROM mitarbeiter;

Aber plötzlich merkst du, dass das Ergebnis kleiner ist als erwartet. Warum? Weil COUNT(spalte) alle Zeilen ignoriert, wo spalte NULL ist.

Lösung: Wenn du wirklich alle Zeilen zählen willst, nimm COUNT(*):

SELECT COUNT(*) AS gesamt_anzahl
FROM mitarbeiter;

Oder sei explizit und zähle nur die Zeilen, wo Bonus nicht NULL ist:

SELECT COUNT(bonus) AS bonus_anzahl
FROM mitarbeiter
WHERE bonus IS NOT NULL;

Hinweis: Wenn du den Unterschied zwischen Einträgen mit NULL und komplett fehlenden Einträgen in der Tabelle beachten willst, wähle bewusst zwischen COUNT(*) und COUNT(spalte).

Fehler 3: Vergessene Filterung mit HAVING statt WHERE

Problem: Du willst Abteilungen finden, wo das Durchschnittsgehalt über 5000 liegt. Ein Newbie schreibt vielleicht sowas:

SELECT department, AVG(gehalt) AS avg_gehalt
FROM mitarbeiter
WHERE AVG(gehalt) > 5000
GROUP BY department;

PostgreSQL wirft einen Fehler:

ERROR: aggregate functions are not allowed in WHERE clause

Das passiert, weil die Filterung mit WHERE vor der Gruppierung passiert, aber Aggregatfunktionen werden erst nach der Gruppierung berechnet. Das heißt, der Durchschnitt AVG(gehalt) ist beim WHERE noch gar nicht berechnet.

Um das zu fixen, benutze HAVING für das Filtern von aggregierten Daten:

SELECT department, AVG(gehalt) AS avg_gehalt
FROM mitarbeiter
GROUP BY department
HAVING AVG(gehalt) > 5000;

Fehler 4: Filterung mit WHERE und Verwirrung bei der Ausführungsreihenfolge

Problem: Du willst wissen, wie viele Mitarbeiter es in Abteilungen gibt, wo das Alter der Mitarbeiter über 30 Jahre ist. Der Query könnte so aussehen:

SELECT department, COUNT(*)
FROM mitarbeiter
GROUP BY department
WHERE alter > 30;

PostgreSQL enttäuscht dich wieder:

ERROR: syntax error at or near "WHERE"

Warum? Der WHERE-Operator wird immer vor GROUP BY verarbeitet. In diesem Fall hast du WHERE einfach an die falsche Stelle gesetzt.

Um das zu vermeiden, ändere die Reihenfolge: Erst filtern, dann gruppieren.

SELECT department, COUNT(*)
FROM mitarbeiter
WHERE alter > 30
GROUP BY department;

Fehler 5: Verwendung von NULL mit SUM(), AVG() und anderen Funktionen

Problem: Du willst den gesamten ausgezahlten Bonus finden und schreibst:

SELECT SUM(bonus) AS gesamt_bonus
FROM mitarbeiter;

Aber dein Ergebnis sieht verdächtig niedrig aus. Das liegt daran, dass bei der Hälfte der Mitarbeiter der Bonus nicht angegeben ist und diese NULL einfach ignoriert werden.

Lösung: Behandle NULL vorher. Zum Beispiel kannst du NULL durch 0 ersetzen:

SELECT SUM(COALESCE(bonus, 0)) AS gesamt_bonus
FROM mitarbeiter;

Jetzt werden alle NULL zu 0 und die Summe stimmt.

Wir schauen uns die Funktion COALESCE noch genauer in ein paar Vorlesungen an.

Fehler 6: Mehrere Aggregatfunktionen ohne deren Zusammenhang zu verstehen

Problem: Du willst die Gesamtanzahl der Mitarbeiter und das gesamte Gehalt berechnen. Aber du schreibst etwas, das komische Ergebnisse liefert:

SELECT COUNT(gehalt) AS anzahl_gehalt, SUM(gehalt) AS gesamt_gehalt
FROM mitarbeiter;

Warum kann das schiefgehen? Wenn jemand ein NULL-Gehalt hat, liefern COUNT(gehalt) und SUM(gehalt) unterschiedliche Ergebnisse, was verwirrend sein kann.

Denk immer dran: Aggregatfunktionen arbeiten unabhängig voneinander. Wenn es NULL gibt, führt das zu unterschiedlichen Resultaten. Nutze COALESCE oder COUNT(*), um Konsistenz zu garantieren:

SELECT COUNT(*) AS gesamt_mitarbeiter, SUM(COALESCE(gehalt, 0)) AS gesamt_gehalt
FROM mitarbeiter;

Fehler 7: Nicht optimierte Queries mit großen Gruppierungen

Problem: Du startest einen Query mit vielen Gruppierungen und er läuft fünf Stunden statt fünf Minuten:

SELECT department, job_titel, standort, COUNT(*)
FROM mitarbeiter
GROUP BY department, job_titel, standort;

Bevor du gruppierst, überleg dir, ob du wirklich alle Spalten im GROUP BY brauchst. Je mehr einzigartige Werte in der Gruppe, desto länger dauert der Query. Wenn möglich, reduziere die Gruppierung:

SELECT department, COUNT(*)
FROM mitarbeiter
GROUP BY department;

Diese Fehler sind weit verbreitet und selbst erfahrene SQL-Entwickler stolpern darüber. Ich hoffe, du kannst jetzt diese Stolpersteine leichter umgehen und Queries schreiben, die schnell, korrekt und elegant laufen.