Grundsatz: SQL (Structured Query Language) ist die Standardsprache für relationale Datenbanken. Mit SQL werden Daten abgefragt, ausgewertet und Tabellen verknüpft.
SQL-Grundstruktur
SELECT [DISTINCT] spalte1, spalte2, aggregat AS alias
FROM tabelle
[JOIN andere_tabelle ON bedingung]
WHERE filterbedingung
GROUP BY spalte1
HAVING aggregat_bedingung
ORDER BY spalte1 [ASC|DESC]
LIMIT n;
SELECT liest Daten aus Tabellen. Die Reihenfolge der Klauseln ist fix; WHERE filtert vor der Aggregation, HAVING nach der Aggregation: Zuerst fallen die Zeilen weg, die WHERE nicht erfüllen, dann werden die Gruppen gebildet und Aggregate berechnet, dann fallen die Gruppen weg, die HAVING nicht erfüllen.
Grundbefehle
-- Einfache Abfrage
SELECT name, ort, umsatz
FROM kunde
WHERE umsatz > 10000
ORDER BY umsatz DESC
LIMIT 10;
-- DISTINCT: nur eindeutige Werte zurückgeben
SELECT DISTINCT ort
FROM kunde;
-- Alias für Spalten und Tabellen
SELECT k.name AS kundenname, k.ort AS stadt
FROM kunde AS k
WHERE k.ort = 'Zürich';
DISTINCT filtert Duplikate aus dem Ergebnis. AS vergibt einen lesbaren Namen (Alias) für Spalten oder Tabellen — praktisch in Berichten und bei JOIN-Abfragen. WHERE filtert Zeilen nach einer Bedingung (umsatz > 10000). ORDER BY sortiert das Ergebnis; mit DESC absteigend (z. B. nach Umsatz), mit ASC aufsteigend.
WHERE — Mehrfachbedingungen
-- AND / OR / NOT
SELECT * FROM kunde
WHERE ort = 'Bern' AND umsatz > 5000;
SELECT * FROM produkt
WHERE kategorie = 'A' OR kategorie = 'B';
-- IN — mehrere Werte in einer Liste
SELECT * FROM kunde
WHERE ort IN ('Zürich', 'Bern', 'Basel');
-- BETWEEN — Wertebereich (inklusiv)
SELECT * FROM bestellung
WHERE betrag BETWEEN 100 AND 500;
-- LIKE — Mustersuche (% = beliebig viele Zeichen, _ = ein Zeichen)
SELECT * FROM kunde
WHERE name LIKE 'Müll%'; -- Müller, Müllemann …
Aggregation
SELECT ort,
COUNT(*) AS anzahl,
SUM(umsatz) AS total,
AVG(umsatz) AS durchschnitt,
MAX(umsatz) AS hoechster,
MIN(umsatz) AS niedrigster
FROM kunde
GROUP BY ort
HAVING SUM(umsatz) > 100000;
GROUP BY fasst Zeilen mit gleichem Wert in einer Spalte zu Gruppen zusammen; die Aggregate (z. B. SUM(umsatz)) werden je Gruppe berechnet. HAVING filtert die bereits gebildeten Gruppen, z. B. «SUM(umsatz) > 100000». Beispiel für den Gesamtumsatz je Region: SELECT region, SUM(umsatz) FROM verkauf GROUP BY region.
Regel: Alle Spalten in SELECT, die keine Aggregatsfunktion sind, müssen in GROUP BY erscheinen; die aggregierten Spalten gehören gerade nicht ins GROUP BY. Ohne GROUP BY darf die SELECT-Liste neben einem Aggregat keine ungruppierte Spalte nennen, weil es sonst mehr als einen möglichen Wert gäbe.
Die fünf gängigen Aggregationsfunktionen sind COUNT, SUM, AVG, MIN und MAX. SELECT selbst ist keine Aggregationsfunktion, sondern der Abfragebefehl.
JOIN-Typen
| Typ | Ergebnis |
|---|---|
INNER JOIN | Nur Zeilen mit Übereinstimmung in beiden Tabellen |
LEFT JOIN | Alle Zeilen links + passende rechts (fehlende = NULL) |
RIGHT JOIN | Alle Zeilen rechts + passende links |
FULL OUTER JOIN | Alle Zeilen aus beiden Tabellen (nicht in jedem Datenbanksystem verfügbar) |
INNER ist die Voreinstellung; LEFT, RIGHT und FULL bezeichnen äussere Verknüpfungen (OUTER ist optional).
-- Bestellungen mit Kundennamen
SELECT k.name, b.datum, b.betrag
FROM kunde k
INNER JOIN bestellung b ON k.id = b.kunde_id
WHERE b.betrag > 200;
Unterabfragen (Subqueries)
Ein SELECT kann innerhalb eines anderen SELECT verschachtelt werden:
-- Subquery in WHERE: Kunden mit überdurchschnittlichem Umsatz
SELECT name, umsatz
FROM kunde
WHERE umsatz > (SELECT AVG(umsatz) FROM kunde);
-- Subquery in FROM (Inline-View)
SELECT ort, avg_umsatz
FROM (
SELECT ort, AVG(umsatz) AS avg_umsatz
FROM kunde
GROUP BY ort
) AS ort_stats
WHERE avg_umsatz > 20000;
Subqueries erlauben mehrstufige Berechnungen, ohne Zwischenergebnisse speichern zu müssen.
SQL-Dialekte — kurzer Hinweis
Grundlegende SQL-Befehle (SELECT, WHERE, JOIN, GROUP BY) sind im ANSI-SQL-Standard definiert und in allen gängigen Datenbanksystemen gleich. Unterschiede gibt es bei:
| Funktion | Verbreitete Variante (z. B. MySQL) | ANSI SQL |
|---|---|---|
| Zeilen begrenzen | LIMIT 10 | FETCH FIRST 10 ROWS ONLY |
| Jahr aus Datum | YEAR(datum) | EXTRACT(YEAR FROM datum) |
| Aktuelle Zeit | NOW() | CURRENT_TIMESTAMP |
| String-Verknüpfung | CONCAT(a, b) | a || b |
Ist kein System vorgegeben, ist ANSI SQL (z. B. EXTRACT) die sichere Wahl.
Beispiel — Top-10-Kunden-Report
SELECT k.name,
SUM(b.betrag) AS umsatz_2025
FROM kunde k
INNER JOIN bestellung b ON k.id = b.kunde_id
WHERE EXTRACT(YEAR FROM b.datum) = 2025
GROUP BY k.id, k.name
ORDER BY umsatz_2025 DESC
LIMIT 10;
Liefert die 10 Kunden mit dem höchsten Bestell-Umsatz im Jahr 2025.
Häufige Fehler
- DELETE ohne WHERE: Löscht die gesamte Tabelle — immer mit WHERE absichern.
- GROUP BY unvollständig: Jede nichtaggregierte Spalte im SELECT muss in GROUP BY stehen.
- WHERE statt HAVING bei Aggregaten:
WHERE SUM(...)ist ungültig; Aggregatfilter gehören inHAVING. - Vervielfachte Zeilen bei JOIN: Stimmt eine Zeile links mit mehreren Zeilen rechts überein, erscheint sie mehrfach. Das ist gewollt, wenn man die rechten Zeilen sehen will; DISTINCT sollte nicht blind eingesetzt werden, um falsche Join-Bedingungen oder doppelt gezählte Summen zu verdecken.
- Subquery-Leistung: Grosse korrelierte Subqueries können langsam sein — ggf. durch JOIN ersetzen.
- Grosse Tabellen ohne Index: Ohne Index muss das System die ganze Tabelle Zeile für Zeile durchsuchen, um passende Zeilen zu finden; ein Index auf der gesuchten Spalte macht das Auffinden effizienter.