Diese Lerneinheit wurde für typische Bachelor-Klausuren konzipiert. So prüfen wir · Fehler entdeckt? Melde ihn uns oder markiere die fragliche Stelle direkt im Text oben.
Alle Tabs der Lerneinheit (Erklärung · Interaktiv · Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur, und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).
SQL (Structured Query Language) ist die Standardsprache zum Abfragen und Verändern relationaler Datenbanken. Du beschreibst deklarativ was du haben willst (welche Spalten, welche Filter), die Datenbank sucht selbst den schnellsten Weg.
SQL (Structured Query Language) ist die Standardsprache zum Abfragen und Verändern relationaler Datenbanken. Du beschreibst deklarativ was du haben willst (welche Spalten, welche Filter), die Datenbank sucht selbst den schnellsten Weg.
Die fünf zentralen Bausteine die in jeder Klausur drankommen:
In Klausuren wirst du oft gefragt: schreibe eine SQL-Query die [Anforderung]. Achte auf die Schreibreihenfolge der Klauseln (SELECT, FROM, WHERE, GROUP BY, HAVING, ORDER BY, LIMIT), und die abweichende logische Auswertungsreihenfolge FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT. WHERE filtert vor der Aggregation, HAVING nach der Aggregation.
Faustregel zum Mitnehmen: SELECT (Spalten) FROM (Tabelle) WHERE (Filter) ORDER BY (Sortierung). Das deckt 80 % aller SQL-Aufgaben in der Klausur ab.
Anmelden, um den Fortschritt zu speichern.
Nächster Schritt
Aktives Abrufen festigt Wissen schneller als nochmal lesen.
Die fünf zentralen Bausteine die in jeder Klausur drankommen:
In Klausuren wirst du oft gefragt: schreibe eine SQL-Query die [Anforderung]. Achte auf die Schreibreihenfolge der Klauseln (SELECT, FROM, WHERE, GROUP BY, HAVING, ORDER BY, LIMIT), und die abweichende logische Auswertungsreihenfolge FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT. WHERE filtert vor der Aggregation, HAVING nach der Aggregation.
Du hast eine Datenbank mit:
Frage: "Welche Informatik-Studierenden haben in 'Algorithmen' bestanden, sortiert nach Note?"
Mit Excel undenkbar. Mit Code einzeln durchsuchen ist Wahnsinn. Mit SQL ist es eine Zeile.
SQL (Structured Query Language) ist die universelle Sprache für relationale Datenbanken, seit 50 Jahren der Standard.
Eine Tabelle ist genau das, was du dir vorstellst, Excel-Layout:
studierende
┌────┬─────────┬──────────────┬──────────┬──────┐
│ id │ name │ studiengang │ semester │ note │
├────┼─────────┼──────────────┼──────────┼──────┤
│ 1 │ Anna │ Informatik │ 3 │ 1.7 │
│ 2 │ Ben │ BWL │ 4 │ 2.3 │
│ 3 │ Clara │ Informatik │ 1 │ 2.0 │
└────┴─────────┴──────────────┴──────────┴──────┘
| Begriff | Was es ist |
|---|---|
| Tabelle (Table) | Sammlung von Zeilen mit gleichem Schema |
| Zeile (Row / Record) | ein Datensatz |
| Spalte (Column / Attribute) | ein Feld mit Typ |
| Primärschlüssel (Primary Key) | eindeutiger Identifier (z.B. id) |
| Fremdschlüssel (Foreign Key) | Verweis auf eine andere Tabelle |
| Befehl | Was er tut | Operation |
|---|---|---|
| SELECT | Daten lesen | Read |
| INSERT | Zeile einfügen | Create |
| UPDATE | Zeile ändern | Update |
| DELETE | Zeile löschen | Delete |
CRUD = Create, Read, Update, Delete. Diese 4 Operationen decken 90 % aller DB-Anwendungen ab. SELECT ist mit Abstand am häufigsten und Klausur-Schwerpunkt.
SELECT name, note
FROM studierende
WHERE studiengang = 'Informatik'
ORDER BY note ASC;
Übersetzung: "Hol mir Name und Note aus der Tabelle studierende, wo der Studiengang Informatik ist, sortiert nach Note aufsteigend."
SELECT spalten
FROM tabelle
WHERE filter-bedingung
GROUP BY spalte
HAVING gruppen-filter
ORDER BY spalte ASC|DESC
LIMIT anzahl
Achtung: in der SQL-Schreibweise steht SELECT zuerst, aber der Datenbank-Optimizer wertet WHERE zuerst aus (filtert), dann GROUP BY, dann erst SELECT (welche Spalten zurück), zuletzt ORDER BY. Klausurfrage gerne.
SELECT *
FROM studierende;
* heißt "alle Spalten". Bequem zum Probieren, aber im Produktivcode vermeiden: explizite Spalten machen schneller und weniger fehleranfällig bei Schema-Änderungen.
SELECT name, note
FROM studierende;
Auch genannt Projektion, nur die gewünschten Spalten "projizieren".
SELECT *
FROM studierende
WHERE studiengang = 'Informatik';
Strings in einfache Anführungszeichen:
'Informatik'. Zahlen direkt:note < 2.0.
Vergleichsoperatoren:
| SQL | Bedeutung |
|---|---|
= | gleich (NICHT ==!) |
!= oder <> | ungleich |
<, <= | kleiner / kleiner gleich |
>, >= | größer / größer gleich |
LIKE | Pattern-Matching mit % (beliebig viele Zeichen) |
IN (...) | in einer Liste |
BETWEEN a AND b | im Bereich (inklusive) |
| / |
Drei separate Queries (jede mit eigenem SELECT ... FROM ...):
SELECT name FROM studierende WHERE name LIKE 'A%'; -- mit A anfangend
SELECT name FROM studierende WHERE name LIKE '%a'; -- mit a endend
SELECT name FROM studierende WHERE name LIKE '%nn%'; -- 'nn' irgendwo (z.B. Anna)
SELECT *
FROM studierende
WHERE studiengang = 'Informatik'
AND note < 2.0;
SELECT *
FROM studierende
WHERE studiengang = 'Informatik'
OR studiengang = 'WI';
AND und OR wie in Java/Python. Klammern für Klarheit benutzen!
-- FALSCH:
WHERE note = NULL -- liefert NICHTS
-- RICHTIG:
WHERE note IS NULL
WHERE note IS NOT NULL
NULL heißt "Wert unbekannt". Vergleich mit
=ist undefiniert. ImmerIS NULLbenutzen.
Drei separate Queries:
SELECT name, note FROM studierende ORDER BY note ASC; -- aufsteigend (Default)
SELECT name, note FROM studierende ORDER BY note DESC; -- absteigend
SELECT name, note FROM studierende ORDER BY studiengang, note; -- erst Studiengang, dann Note
ASC ist Standard (kann weggelassen werden). DESC für umgekehrt. Eine Query darf nur eine
ORDER BY-Klausel haben, mehrere Sortierkriterien werden mit Komma getrennt aufgelistet.
SELECT * FROM studierende
ORDER BY note ASC
LIMIT 5; -- Top 5 (beste Noten zuerst)
Dialektabhängig:
LIMIT nist Standard in PostgreSQL, MySQL, SQLite. Im portablen SQL-Standard lautet die VarianteFETCH FIRST n ROWS ONLY(auch in PostgreSQL akzeptiert). SQL Server nutztSELECT TOP n. In Klausuren die im Kurs verwendete Konvention nehmen.
Wichtig für Pagination (Seiten-weise Anzeige):
LIMIT 10 OFFSET 20= Zeilen 21–30.
SELECT DISTINCT studiengang
FROM studierende;
-- → Informatik, BWL, WI, Data Science (nur 4 Zeilen, jeder einmal)
INSERT INTO studierende (name, studiengang, semester, note)
VALUES ('Felix', 'Informatik', 6, 2.7);
Spalten in Klammern, Werte parallel. Wenn Spaltennamen weggelassen → Reihenfolge der Tabelle muss passen.
UPDATE studierende
SET note = 1.0
WHERE name = 'Anna';
WICHTIG: ohne WHERE wird JEDE Zeile geändert. Klausur-Klassiker und Produktiv-Falle!
DELETE FROM studierende
WHERE id = 5;
Genauso: ohne WHERE → komplette Tabelle leer. Im Echt-System mit Transaktion absichern.
Trick 1, Strings in einfache Anführungszeichen: 'Informatik'. Doppel-Quotes sind je nach DB für Spaltennamen reserviert. Klausur-Falle.
Trick 2, = für Gleichheit, NICHT ==: SQL hat KEIN ==. Anfänger-Fehler aus Java/Python.
Trick 3, NULL-Vergleich nur mit IS NULL: = NULL liefert immer NULL (≠ true). Daher IS NULL.
Trick 4, UPDATE/DELETE OHNE WHERE: ändert / löscht ALLE Zeilen. Immer prüfen.
Trick 5, Auswertungs-Reihenfolge (innerlich):
1. FROM , Tabelle laden
2. WHERE , filtern
3. GROUP BY , gruppieren
4. HAVING , Gruppen filtern
5. SELECT , Spalten wählen
6. ORDER BY , sortieren
7. LIMIT , begrenzen
SELECT steht zwar oben, wird aber spät ausgewertet.
Trick 6, Aliase mit AS:
SELECT name AS Name, note AS Bewertung
FROM studierende AS s
WHERE s.note < 2.0;
Übersichtlicher in komplexen Queries.
Trick 7, Komma-Liste in IN():
WHERE studiengang IN ('Informatik', 'WI', 'Data Science')
-- ist gleich:
WHERE studiengang = 'Informatik'
OR studiengang = 'WI'
OR studiengang = 'Data Science'
Trick 8, BETWEEN ist inklusiv:
WHERE note BETWEEN 1.0 AND 2.0
-- ist gleich:
WHERE note >= 1.0 AND note <= 2.0
Trick 9, Semikolon am Ende: jede SQL-Anweisung wird mit ; abgeschlossen. Manche Tools verlangen das, andere optional.
Trick 10, Groß-/Kleinschreibung von SQL: SELECT, select, Select sind alle gleich. Konvention: SQL-Keywords groß, Spaltennamen klein.
Faustregel: SQL ist die zweite Programmiersprache, die jeder kann sollte. Selbst Frontend-Entwickler brauchen mindestens SELECT regelmäßig.
Vorgegebene Tabelle studierende mit 8 Zeilen. Bau dir deine Query mit:
Die generierte SQL-Query siehst du oben (kopierfähig), das Ergebnis als Tabelle unten.
Probier folgendes:
< strikt ist (nicht <=)Mode-Switch:
Interaktive Visualisierung
Live-SQL-Editor mit Mini-Datenbank und Ergebnis-Tabelle pro Query.
Faustregel zum Mitnehmen: SELECT (Spalten) FROM (Tabelle) WHERE (Filter) ORDER BY (Sortierung). Das deckt 80 % aller SQL-Aufgaben in der Klausur ab.
Klausurfragen mit Lösungen (8)
Antwort: SELECT
Erklärung: SELECT ist der SQL-Standard zum Lesen. CRUD-Operationen: SELECT (Read), INSERT (Create), UPDATE (Update), DELETE (Delete). Andere Befehle wie GET sind aus REST-APIs, nicht SQL.
Antwort: WHERE
Erklärung: WHERE filtert Zeilen vor der Ausgabe. ORDER BY sortiert (ändert Reihenfolge). GROUP BY fasst Zeilen zu Gruppen zusammen (für Aggregate). FILTER BY existiert in Standard-SQL nicht.
Antwort: WHERE name = 'Anna'
Erklärung: Strings in SQL stehen in EINFACHEN Anführungszeichen ('Anna'). Doppel-Quotes ("...") sind je nach DB für Spaltennamen mit Sonderzeichen reserviert. Backticks sind MySQL-spezifisch für Bezeichner.
Antwort: ALLE Zeilen werden auf note=1.0 gesetzt
Erklärung: Ohne WHERE wirkt UPDATE auf JEDE Zeile! Klausur-Klassiker und Produktiv-Falle. Immer prüfen, dass WHERE da steht. Manche DB-Tools warnen, aber Standard-SQL erlaubt es.
Antwort: WHERE note IS NULL
Erklärung: NULL ist ein Sonderwert ('unbekannt'). Vergleich mit = liefert IMMER NULL (≠ true). Daher IS NULL bzw. IS NOT NULL benutzen. Klausur-Klassiker.
Antwort: FROM → WHERE → SELECT → ORDER BY
Erklärung: Vollständige logische Reihenfolge: FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT. Bei einer einfachen Query ohne Aggregation reduziert sich das auf FROM → WHERE → SELECT → ORDER BY (Antwort B). SELECT steht in der Schreibweise oben, wird aber spät ausgewertet, Hintergrundwissen für Optimizer.
Antwort: WHERE name LIKE 'A%'
Erklärung: LIKE mit % (= beliebige Zeichen) ist SQL-Standard. 'A%' = mit A anfangen, '%a' = mit a enden, '%nn%' = nn enthalten. = liefert nur exakte Matches, * gibt's nicht in Standard-SQL (manche DBs unterstützen REGEX).
Antwort: Nur die unterschiedlichen Studiengänge (z.B. Informatik, BWL, WI, Data Science)
Erklärung: DISTINCT entfernt Duplikate aus der Ergebnis-Liste. Bei Studiengängen: 8 Zeilen werden zu 4 unique Einträgen reduziert (Informatik, BWL, WI, Data Science). Praktisch für 'welche Werte gibt es überhaupt'-Abfragen.
IS NULLIS NOT NULL| für NULL-Werte |