Verwendung von Subqueries in FROM

Lass uns noch tiefer in den Kaninchenbau eintauchen: Wir schauen uns an, wie man Subqueries im FROM-Block verwendet. Das ist einer der beliebtesten Tricks von SQL-Entwicklern, weil du damit richtig mächtige temporäre Tabellen direkt "vor Ort" bauen und wiederverwenden kannst, als ob sie schon in der Datenbank existieren würden.

Stell dir vor, du bastelst einen Report, der Berechnungen, Gruppierungen oder Filterungen braucht, aber du willst keine extra temporären Tabellen auf dem Server anlegen. Was tun? Genau hier kommen Subqueries im FROM ins Spiel. Sie ermöglichen dir:

• Daten temporär zusammenzufassen oder zu aggregieren, bevor der Hauptquery läuft.
• Strukturierte Datensätze "on the fly" zu erstellen.
• Die Anzahl der Operationen zu reduzieren, sodass die Datenbank möglichst wenig Zwischenstände speichern muss.

Subqueries im FROM funktionieren wie Mini-Tabellen, die du im Hauptquery verwenden kannst. Das ist wie Lego bauen: schnell, flexibel und ohne viel Overhead :)

Basics von Subqueries im FROM

Bei Subqueries im FROM nutzt du eine Subquery, um eine temporäre Tabelle (oder Subtabelle) zu erstellen, die dann Teil des Gesamtqueries wird. Dafür brauchst du drei wichtige Schritte:

1. Schreib die Subquery im FROM-Block in runde Klammern.
2. Gib der Subquery einen Alias (also einen Spitznamen).
3. Benutze diesen Alias, als wäre es eine ganz normale Tabelle.

Syntax

SELECT spalten
FROM (
    SELECT spalten
    FROM tabelle
    WHERE bedingung
) AS alias
WHERE äußere_bedingung;

Klingt erstmal wild? Lass uns direkt zu Beispielen springen.

Beispiel: Studenten und Durchschnittsnote

Nehmen wir an, wir haben zwei Tabellen:

students (Infos über Studenten – ihr Name und ihre ID):

grades (Infos zu den Noten der Studenten):

Jetzt die Aufgabe: Liste der Studenten und deren Durchschnittsnote holen.

Wir starten mit einer einfachen Subquery, die für jeden Studenten die Durchschnittsnote berechnet, und nutzen das dann im Hauptquery.

SELECT s.student_name, g.avg_grade
FROM (
    SELECT student_id, AVG(grade) AS avg_grade
    FROM grades
    GROUP BY student_id
) AS g
JOIN students AS s ON s.student_id = g.student_id;

Ergebnis:

Temporäre Tabellen "on the fly"

Subqueries im FROM sind besonders praktisch, wenn du mehr als eine Ebene Datenverarbeitung brauchst. Zum Beispiel, wenn du nicht nur die Durchschnittsnote willst, sondern auch die höchste Note für jeden Studenten – alles in einem Query.

SELECT g.student_id, g.avg_grade, g.max_grade
FROM (
    SELECT student_id, 
           AVG(grade) AS avg_grade, 
           MAX(grade) AS max_grade
    FROM grades
    GROUP BY student_id
) AS g;

Ergebnis:

Check mal, das funktioniert wie eine richtige temporäre Tabelle mit eigenen Spalten: avg_grade und max_grade.

Wann sind Subqueries im FROM am besten?

Für aggregierte Daten. Wenn du erst Berechnungen machen willst (z.B. Durchschnitt, Summen oder Maxima), und dann die Ergebnisse mit anderen Tabellen joinen willst.

Für Datenfilterung. Wenn du Daten vor dem Join mit der Haupttabelle filtern willst.

Um komplexe Queries zu vereinfachen. Komplexe Aufgaben in Schritte zu teilen, hilft dir, den Überblick zu behalten.

Beispiel: Studenten-Report mit zwei Verarbeitungsebenen

Stell dir vor, wir wollen Studenten finden, deren Durchschnittsnote über 80 liegt. Wir starten mit einer Subquery, die die Durchschnittsnoten berechnet, und nutzen das dann im Filter.

SELECT s.student_name, g.avg_grade
FROM students AS s
JOIN (
    SELECT student_id, AVG(grade) AS avg_grade
    FROM grades
    GROUP BY student_id
) AS g ON s.student_id = g.student_id
WHERE g.avg_grade > 80;

Ergebnis:

Tipps und Besonderheiten

Alias ist Pflicht. Gib deiner Subquery immer einen Alias (z.B. AS g), sonst weiß PostgreSQL nicht, wie es auf diese "temporäre Tabelle" zugreifen soll.

Optimierung. Subqueries im FROM können langsamer sein als Table-Joins (JOIN), besonders wenn du in der Subquery filterst.

Indexierung. Achte darauf, dass die Felder, die du zum Joinen nutzt, indiziert und optimiert sind – das macht echt einen Unterschied bei der Performance.

Beispiel für einen komplexeren Query: Kurse und Anzahl der Studenten

Jetzt machen wir mal eine etwas schwierigere Aufgabe. Stell dir vor, wir haben diese Tabelle:

courses (Liste der Kurse):

Und enrollments (Studenten, die sich für Kurse eingeschrieben haben):

Jetzt wollen wir wissen, wie viele Studenten in jedem Kurs eingeschrieben sind.

SELECT c.course_name, e.students_count
FROM courses AS c
JOIN (
    SELECT course_id, COUNT(student_id) AS students_count
    FROM enrollments
    GROUP BY course_id
) AS e ON c.course_id = e.course_id;

Ergebnis:

Ich hoffe, dir hat die Vorlesung gefallen... aber die nächste wird noch spannender :)