SQL Grundlagen.

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:

• SELECT: welche Spalten du sehen willst, optional mit DISTINCT für eindeutige Werte
• FROM: aus welcher Tabelle (oder welchen Tabellen mit JOIN)
• WHERE: Filter auf Zeilen-Ebene, vor der Aggregation
• GROUP BY + Aggregat-Funktionen (COUNT, SUM, AVG, MIN, MAX): Daten zusammenfassen
• ORDER BY: nach welcher Spalte sortieren, ASC oder DESC

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.

Das Problem

Du hast eine Datenbank mit:

• 50.000 Studierenden
• 200 Vorlesungen
• 1 Million Klausur-Einträgen

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.

Tabellen, Zeilen, Spalten

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  │
└────┴─────────┴──────────────┴──────────┴──────┘

Die wichtigsten 4 Befehle (CRUD)

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: Daten lesen

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."

Die SQL-Reihenfolge

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.

Beispiele aufbauend

Alle Spalten, der Stern

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.

Nur ausgewählte Spalten

SELECT name, note
FROM studierende;

Auch genannt Projektion, nur die gewünschten Spalten "projizieren".

Filter mit WHERE

SELECT *
FROM studierende
WHERE studiengang = 'Informatik';

Strings in einfache Anführungszeichen: 'Informatik'. Zahlen direkt: note < 2.0.

Vergleichsoperatoren:

LIKE für Pattern-Suche

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)

Mehrere Bedingungen

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!

NULL, der Sonderfall

-- 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. Immer IS NULL benutzen.

Sortieren mit ORDER BY

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.

Begrenzen mit LIMIT

SELECT * FROM studierende
ORDER BY note ASC
LIMIT 5;        -- Top 5 (beste Noten zuerst)

Dialektabhängig: LIMIT n ist Standard in PostgreSQL, MySQL, SQLite. Im portablen SQL-Standard lautet die Variante FETCH FIRST n ROWS ONLY (auch in PostgreSQL akzeptiert). SQL Server nutzt SELECT TOP n. In Klausuren die im Kurs verwendete Konvention nehmen.

Wichtig für Pagination (Seiten-weise Anzeige): LIMIT 10 OFFSET 20 = Zeilen 21–30.

DISTINCT, Duplikate entfernen

SELECT DISTINCT studiengang
FROM studierende;
-- → Informatik, BWL, WI, Data Science (nur 4 Zeilen, jeder einmal)

INSERT, UPDATE, DELETE

INSERT, Zeile einfügen

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, ändern

UPDATE studierende
SET note = 1.0
WHERE name = 'Anna';

WICHTIG: ohne WHERE wird JEDE Zeile geändert. Klausur-Klassiker und Produktiv-Falle!

DELETE, löschen

DELETE FROM studierende
WHERE id = 5;

Genauso: ohne WHERE → komplette Tabelle leer. Im Echt-System mit Transaktion absichern.

Klausur-Tricks

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.

Wo brauchst du SQL?

• Web-Apps: jede E-Commerce-Seite, jedes CMS, jede Login-Funktion
• Daten-Analysen: Tableau, Power BI, Excel mit DB-Anschluss
• Reporting: Monats-Berichte, Dashboards
• Data Science: Pandas + SQL, BigQuery, ETL-Pipelines
• Backend-Entwicklung: 90 % aller Datenbanken sind SQL-basiert
• DevOps: Logs in DB speichern + abfragen

Faustregel: SQL ist die zweite Programmiersprache, die jeder kann sollte. Selbst Frontend-Entwickler brauchen mindestens SELECT regelmäßig.

SQL-Lab

Vorgegebene Tabelle studierende mit 8 Zeilen. Bau dir deine Query mit:

• SELECT-Buttons: welche Spalten in der Ausgabe?
• WHERE-Filter: Spalte, Operator, Wert
• ORDER BY: nach welcher Spalte sortieren, ASC/DESC

Die generierte SQL-Query siehst du oben (kopierfähig), das Ergebnis als Tabelle unten.

Probier folgendes:

• Lade Preset "Informatik-Studis" → 3 Treffer
• WHERE note < 2.0, ORDER BY note ASC → Eva (1.3), Anna (1.7), Greta (1.7), Clara und Hans (2.0) sind ausgeschlossen, weil < strikt ist (nicht <=)
• WHERE name LIKE '%a' → alle, deren Name mit 'a' endet (Anna, Clara, Eva, Greta)
• Toggle SELECT-Spalten an/aus, beobachte das Ergebnis

Mode-Switch:

• Frei, eigene Queries
• Vorhersagen, schätze Treffer-Anzahl vor dem Filtern
• Aufgabe, 4 konkrete Aufgaben mit Hinweis und Lösung

Faustregel zum Mitnehmen: SELECT (Spalten) FROM (Tabelle) WHERE (Filter) ORDER BY (Sortierung). Das deckt 80 % aller SQL-Aufgaben in der Klausur ab.