Block 01 · Datenbanken

A · Erklärungssatz

Die Beispiele in diesem Teil verwenden bewusst andere Szenarien (Musikschule, Fitnessstudio) als die Aufgaben in Teil C (Fahrradverleih VeloPunkt). So lernst du die Methode, ohne die Lösung schon zu kennen.

DB-01 · ER-/Relationenmodell Immer

Vorkommen: 9/9 · Prüfungen: alle (W21–S26) · meist Teil 2, Aufgabe 3 (16–25 P), zusätzlich in Teil 1 (W21, S23, W23, S24, W25)

Worum geht es?

Eine Datenbank wird in zwei Stufen entworfen:

1. Konzeptionell – ER-Modell (Entity-Relationship-Modell): beschreibt den Ausschnitt der Realität mit Entitäten, Beziehungen und Attributen – unabhängig davon, welches Datenbanksystem später verwendet wird.
2. Logisch – Relationenmodell (relationales Datenmodell): Tabellen mit Spalten, Primärschlüsseln (PK) und Fremdschlüsseln (FK). Es lässt sich direkt in CREATE TABLE-Befehle umsetzen.

In der Prüfung wird meist das Relationenmodell in 3. Normalform verlangt („Erstellen Sie ein relationales Datenmodell in 3NF …“), seltener ein ER-Modell (W21 T1, W23 T1, S24 T1).

Begriffe

Notation (Chen-Notation wie im IHK-Belegsatz)

Der Belegsatz zeigt nur die drei Symbole: Rechteck = Entität, Raute = Beziehung, Ellipse = Attribut. Die Kardinalitäten stehen nicht im Belegsatz – die musst du kennen. Man schreibt sie als 1, n oder m an die Verbindungslinien.

So liest du eine Beziehung: Von einer Entität über die Raute zur Zahl auf der anderen Seite: „Eine Abteilung beschäftigt n Mitarbeiter“ und „Ein Mitarbeiter wird von 1 Abteilung beschäftigt.“ Die Zahl steht also an der Entität, deren Anzahl sie angibt.

Ergänzung: Manche Lehrbücher nutzen die modifizierte Chen-Notation mit c (0 oder 1) und mc (0 bis viele) oder die Min-Max-Notation (0,1), (1,*). In den IHK-Lösungen genügen 1, n, m.

Besondere Beziehungen

• Rekursive Beziehung: Ein Entitätstyp steht mit sich selbst in Beziehung, z. B. „Lehrkraft betreut Lehrkraft“ (Mentor). Zwei Linien von derselben Entität zur Raute; die Rollen (Mentor/Mentee) an die Linien schreiben.
• Beziehung mit Attribut: Das Attribut (Ellipse) hängt an der Raute, z. B. Anmeldedatum an „belegt“. Typisch bei m:n: Menge, Datum, Note, Anzahl, Preis zum Zeitpunkt.
• Mehrere Beziehungen zwischen denselben Entitätstypen: z. B. Spiel – Mannschaft als „Heimmannschaft“ und „Gastmannschaft“. Jede Beziehung wird einzeln modelliert (zwei Rauten).
• Soft Delete (S24): Datensätze werden nicht physisch gelöscht, sondern als gelöscht markiert, z. B. Attribut geloescht (boolean) oder GeloeschtAm (Datum). So bleiben Historie und Bezüge erhalten.

Beispiel Musikschule: Eine Lehrkraft leitet mehrere Kurse, jeder Kurs hat genau eine Lehrkraft. Schüler belegen beliebig viele Kurse, ein Kurs hat viele Schüler; gespeichert wird das Anmeldedatum. Erfahrene Lehrkräfte betreuen als Mentor mehrere neue Lehrkräfte, jede Lehrkraft hat höchstens einen Mentor. Ein Schüler kann höchstens ein Leihinstrument ausleihen, ein Leihinstrument ist höchstens an einen Schüler verliehen.

Vom ER-Modell zum Relationenmodell

Zwei übliche Darstellungen (beide werden in der Prüfung akzeptiert):

1. Textnotation: Kurs(KursNr, Titel, Wochentag, ↑LehrerNr) – PK unterstrichen, FK mit ↑ (alternativ # oder „(FK)“) gekennzeichnet.
2. Tabellen-Kästen (so zeichnen die IHK-Lösungen): Tabellenname als Kopf, darunter die Attribute mit „(PK)“/„(FK)“, Verbindungslinien zwischen den Tabellen mit 1 und n an den Enden.

Überführungsregeln

Dasselbe Modell in Textnotation:

Lehrkraft(LehrerNr, Name, Telefon, ↑MentorNr)

Kurs(KursNr, Titel, Wochentag, ↑LehrerNr)

Schueler(SchuelerNr, Vorname, Nachname, Geburtsdatum)

Belegung(↑SchuelerNr, ↑KursNr, Anmeldedatum)

Leihinstrument(InstrumentNr, Bezeichnung, ↑SchuelerNr) – SchuelerNr ist UNIQUE (1:1)

So gehst du vor (Teil 2, Aufgabe 3)

1. Text/Formular durcharbeiten: Substantive → Kandidaten für Tabellen und Attribute, Verben → Beziehungen.
2. Je Tabelle alle genannten Attribute sammeln. „Übernehmen Sie alle genannten Attribute“ bringt Punkte – nichts weglassen.
3. PK festlegen (vorhandene Nummer oder künstliche ID).
4. Kardinalität jeder Beziehung mit den zwei Fragen bestimmen.
5. 1:n → FK auf die n-Seite; m:n → Zwischentabelle; 1:1 → FK + UNIQUE.
6. Beziehungsattribute (Menge, Datum, Anzahl, Note) in die Zwischentabelle.
7. 3NF prüfen (→ DB-02): keine Mehrfachwerte, keine berechneten Werte, keine transitiven Abhängigkeiten.
8. Zeichnen: jede Linie mit 1/n beschriften, FKs kennzeichnen. Ein vorgegebenes ERM vollständig übernehmen – auch die schon gegebenen Beziehungen bringen Punkte.

DB-02 · Normalisierung 1NF–3NF Immer

Vorkommen: 8/9 · Prüfungen: alle außer S24 · Teil 2, Aufgabe 3 und Teil 1 (S23, W25)

Warum normalisieren?

Redundanz = dieselbe Information ist mehrfach gespeichert. Das kostet Speicher, vor allem aber führt es zu Inkonsistenzen (widersprüchlichen Daten), weil Änderungen nicht überall nachgezogen werden. Ziel der Normalisierung: jede Information genau einmal speichern und so Anomalien verhindern.

Beispiel – unnormalisierte Kursliste einer Musikschule (Excel):

Anomalien

Grundbegriffe

• Funktionale Abhängigkeit A → B: Zu jedem Wert von A gehört genau ein Wert von B. Beispiel: LehrerNr → Lehrer (L7 gehört immer zu Petra Lang). Umgekehrt muss das nicht gelten (zwei Lehrkräfte könnten gleich heißen).
• Voll funktionale Abhängigkeit: B hängt vom gesamten (zusammengesetzten) Schlüssel ab, nicht nur von einem Teil davon.
• Transitive Abhängigkeit: Schlüssel → A → B, wobei A selbst kein Schlüssel ist. Beispiel: KursNr → LehrerNr → Lehrer.
• Schlüsselkandidat: minimale Attributkombination, die jede Zeile eindeutig identifiziert; einer davon wird Primärschlüssel. Nichtschlüsselattribut: gehört zu keinem Schlüsselkandidaten.

Die drei Normalformen

Durchgerechnetes Beispiel: Kursliste → 3NF

1NF: Je Kurs und Teilnehmer eine eigene Zeile, Namen zerlegt. Schlüssel: (KursNr, SchuelerNr).

Kursliste(KursNr, SchuelerNr, Kurstitel, LehrerNr, LehrerVorname, LehrerNachname, Raum, SchuelerVorname, SchuelerNachname)

2NF: Kurstitel, LehrerNr, Lehrername und Raum hängen nur von KursNr ab, die Schülernamen nur von SchuelerNr → auslagern.

Kurs(KursNr, Kurstitel, LehrerNr, LehrerVorname, LehrerNachname, Raum)

Schueler(SchuelerNr, Vorname, Nachname)

Belegung(↑KursNr, ↑SchuelerNr)

3NF: In Kurs hängen die Lehrernamen transitiv über LehrerNr vom PK ab → eigene Tabelle.

Lehrkraft(LehrerNr, Vorname, Nachname)

Kurs(KursNr, Kurstitel, Raum, ↑LehrerNr)

Schueler(SchuelerNr, Vorname, Nachname)

Belegung(↑KursNr, ↑SchuelerNr)

Hätte ein Raum weitere Eigenschaften (Größe, Etage), bekäme auch er eine eigene Tabelle Raum(RaumNr, …) und Kurs einen FK RaumNr.

Formular/Beleg → 3NF: So gehst du vor

1. Alle Felder des Formulars als Attributliste aufschreiben – auch Kopf- und Fußdaten.
2. Berechnete Felder streichen (Positionsbetrag, Summe, Steuerbetrag, Alter) – sie werden bei Bedarf per SQL berechnet.
3. Zusammengesetzte Felder zerlegen (Name, Anschrift).
4. Wiederholgruppen (z. B. Positionen) erkennen → eigene Tabelle mit FK zum Kopf (1NF).
5. Für jede Attributgruppe fragen: „Wovon hängt dieser Wert ab?“ → je „Ding“ (Person, Artikel, Ort …) eine Tabelle (2NF/3NF).
6. Historische Werte bewusst speichern: Ein Preis, der zum Zeitpunkt des Belegs galt, gehört in die Positionstabelle, weil sich der aktuelle Preis ändern kann. Das ist keine Redundanz im Sinne der Normalisierung.
7. Beziehungen, Kardinalitäten und FKs eintragen.

DB-03 · SQL: SELECT mit JOIN Immer

Vorkommen: 9/9 · Prüfungen: alle · Teil 2, Aufgabe 4 (die SQL-Aufgabe ist in allen 9 Prüfungen Aufgabe 4 von Teil 2)

Aufbau einer Abfrage

SELECT   Spalten / Ausdrücke [AS Alias]   -- was wird angezeigt?
FROM     Tabelle [Alias]
  [INNER | LEFT] JOIN Tabelle2 ON Bedingung
WHERE    Bedingung für einzelne Zeilen
GROUP BY Spalten
HAVING   Bedingung für Gruppen
ORDER BY Spalte [ASC | DESC], …;

Bedingungen in WHERE

Texte und Datumswerte stehen in einfachen Anführungszeichen, Zahlen ohne. Dezimalpunkt statt Komma (9.50). Datumsliterale im Format 'JJJJ-MM-TT'.

Funktionen, berechnete Spalten, Alias

Dialekt-Hinweis: Im IHK-Belegsatz (z. B. S22) steht DATEDIFF(Datumsteil, Anfangsdatum, Enddatum) sowie TODAY/CURRENT (SQL-Server-Stil). Verwende in der Prüfung die Schreibweise aus dem Belegsatz deiner Prüfung; sinnvolle Varianten werden akzeptiert.

SELECT Nachname, Ort, YEAR(Eintritt) AS Jahr
FROM   Mitglied
WHERE  YEAR(Eintritt) >= 2025 AND (Ort = 'Bonn' OR Ort = 'Siegburg')
ORDER BY Eintritt;

SELECT Titel, Preis, Preis * 10 AS Zehnerkarte, Preis * 10 * 0.9 AS ZehnerkarteRabatt
FROM   Kurs
WHERE  Titel LIKE '%ing%' OR Titel LIKE 'Y%';

JOIN-Arten

Ein JOIN verbindet Tabellen über ihre Beziehung, fast immer FK = PK. Fehlt die ON-Bedingung, entsteht das kartesische Produkt (jede Zeile mit jeder).

SELECT k.Titel, t.Name
FROM   Kurs k
  INNER JOIN Trainer t ON t.TrainerNr = k.TrainerNr;   -- bzw. LEFT JOIN / RIGHT JOIN

Mehrere Tabellen verbindet man als Kette entlang der Fremdschlüssel. Tabellenaliase (m, b, k) sparen Schreibarbeit und machen Spaltennamen eindeutig:

SELECT m.Nachname, k.Titel, b.Datum
FROM   Mitglied m
  INNER JOIN Buchung b ON b.MitgliedNr = m.MitgliedNr
  INNER JOIN Kurs k    ON k.KursNr     = b.KursNr
WHERE  m.Ort = 'Bonn'
ORDER BY b.Datum;

Die ältere Schreibweise FROM Mitglied m, Buchung b, Kurs k WHERE b.MitgliedNr = m.MitgliedNr AND … ist gleichwertig zum INNER JOIN und wird akzeptiert. Für einen LEFT JOIN braucht man aber die JOIN-Syntax.

Die LEFT-JOIN-Falle: Bedingung in ON oder in WHERE?

Aufgabe: „Alle Mitglieder mit ihren Buchungen im April – auch Mitglieder ohne April-Buchung sollen erscheinen.“

SELECT m.Nachname, b.Datum
FROM   Mitglied m
  LEFT JOIN Buchung b
    ON  b.MitgliedNr = m.MitgliedNr
    AND MONTH(b.Datum) = 4
ORDER BY m.Nachname;

SELECT m.Nachname, b.Datum
FROM   Mitglied m
  LEFT JOIN Buchung b
    ON  b.MitgliedNr = m.MitgliedNr
WHERE  MONTH(b.Datum) = 4
ORDER BY m.Nachname;

WHERE wird nach dem Join ausgewertet. Für „Wolf“ ist b.Datum NULL, MONTH(NULL) = 4 ist nicht wahr → die Zeile fällt heraus. Der LEFT JOIN wirkt dann wie ein INNER JOIN. Ebenso würden Mitglieder fehlen, die nur im März gebucht haben.

DB-04 · SQL: Aggregatfunktionen, GROUP BY und HAVING Immer

Vorkommen: 8/9 · Prüfungen: alle außer W24 · Teil 2, Aufgabe 4

Aggregatfunktionen

SELECT COUNT(*) AS Anzahl, MIN(Preis) AS Min, MAX(Preis) AS Max,
       SUM(Preis) AS Summe, AVG(Preis) AS Schnitt
FROM   Kurs;

SELECT COUNT(*) AS alle, COUNT(TrainerNr) AS mitTrainer, COUNT(DISTINCT TrainerNr) AS versch
FROM   Kurs;

GROUP BY

Ohne GROUP BY fasst eine Aggregatfunktion die ganze (gefilterte) Tabelle zu einer Zeile zusammen. Mit GROUP BY entsteht je Gruppe eine Zeile.

Beispiel: Anzahl Buchungen je Kurs – auch Kurse ohne Buchung:

SELECT k.Titel, COUNT(b.BuchungNr) AS Anzahl, COUNT(*) AS Zeilen
FROM   Kurs k
  LEFT JOIN Buchung b ON b.KursNr = k.KursNr
GROUP BY k.KursNr, k.Titel
ORDER BY Anzahl DESC;

„Boxen“ hat keine Buchung. Nach dem LEFT JOIN existiert trotzdem eine Zeile (mit NULL in den Buchungsspalten). COUNT(*) zählt diese Zeile mit (1), COUNT(b.BuchungNr) zählt nur echte Buchungen (0).

WHERE oder HAVING?

SELECT m.MitgliedNr, m.Nachname, COUNT(*) AS Buchungen
FROM   Mitglied m
  INNER JOIN Buchung b ON b.MitgliedNr = m.MitgliedNr
WHERE  YEAR(b.Datum) = 2026          -- Zeilenfilter
GROUP BY m.MitgliedNr, m.Nachname
HAVING COUNT(*) >= 2;                -- Gruppenfilter

So gehst du vor

1. „je …“, „pro …“, „für jede(n) …“ → das ist die GROUP-BY-Spalte (plus die Spalten, die dazu angezeigt werden sollen).
2. „Anzahl“ → COUNT, „Summe/Umsatz/Gesamt“ → SUM, „Durchschnitt“ → AVG, „höchste/niedrigste/letzte“ → MAX/MIN.
3. Bedingung an Einzelzeilen (Jahr, Status, Ort) → WHERE. Bedingung an das Gruppenergebnis („mehr als 3“, „Summe über 100 €“) → HAVING.
4. „auch … ohne …“ / „mit 0“ → LEFT JOIN und COUNT(Spalte der rechten Tabelle).
5. Sortieren nach dem Aggregat: ORDER BY Anzahl DESC (Alias) oder ORDER BY COUNT(*) DESC.

DB-05 · SQL: INSERT, UPDATE, DELETE Meistens

Vorkommen: 7/9 · Prüfungen: W21, S22, W22, W23, S24, W25, S26 · Teil 2, Aufgabe 4

INSERT – Datensätze einfügen

INSERT INTO Mitglied (MitgliedNr, Vorname, Nachname, Ort, Eintritt)
VALUES (5, 'Eva', 'Lorenz', 'Bonn', '2026-10-01');

-- mehrere Zeilen auf einmal
INSERT INTO Trainer (TrainerNr, Name)
VALUES (4, 'Kai Brehm'), (5, 'Ina Vogt');

• Spaltenliste immer angeben – dann ist die Reihenfolge der Spalten in der Tabelle egal und fehlende Spalten bekommen NULL bzw. ihren DEFAULT.
• Werte in derselben Reihenfolge wie die Spaltenliste; Text und Datum in '…', Zahlen ohne, NULL ohne Anführungszeichen.
• Eine Spalte mit AUTO_INCREMENT lässt man weg – das DBMS vergibt die Nummer.

UPDATE – Werte ändern

UPDATE Kurs
SET    Preis = Preis * 1.05              -- Preis um 5 % erhöhen
WHERE  TrainerNr = 1;

-- mit Unterabfrage (die Nummer ist nicht bekannt, nur der Name)
UPDATE Kurs
SET    Preis = Preis - 1
WHERE  TrainerNr = (SELECT TrainerNr FROM Trainer WHERE Name = 'Omar Haddad');

-- MySQL-Variante: UPDATE mit JOIN
UPDATE Kurs k
  INNER JOIN Trainer t ON t.TrainerNr = k.TrainerNr
SET    k.Preis = k.Preis - 1
WHERE  t.Name = 'Omar Haddad';

DELETE – Datensätze löschen

DELETE FROM Buchung
WHERE  Datum < '2026-04-01';

Referenzielle Integrität: Ein Datensatz, auf den noch ein Fremdschlüssel zeigt, kann (ohne ON DELETE CASCADE) nicht gelöscht werden. Deshalb gilt:

• Löschen: erst die Datensätze in der Kind-Tabelle (mit dem FK), dann den Datensatz in der Eltern-Tabelle.
• Einfügen: umgekehrt – erst Eltern, dann Kind.

-- Mitglied 2 vollständig löschen
DELETE FROM Buchung  WHERE MitgliedNr = 2;   -- 1. Kind
DELETE FROM Mitglied WHERE MitgliedNr = 2;   -- 2. Eltern

Archivierungsmuster: INSERT … SELECT + DELETE

Alte Datensätze werden aus der Arbeitstabelle in eine Archivtabelle verschoben: Die Arbeitstabelle bleibt klein und schnell, die Historie bleibt erhalten.

START TRANSACTION;

INSERT INTO Buchung_Archiv (BuchungNr, MitgliedNr, KursNr, Datum)
SELECT BuchungNr, MitgliedNr, KursNr, Datum
FROM   Buchung
WHERE  Datum < '2026-04-01';

DELETE FROM Buchung
WHERE  Datum < '2026-04-01';

COMMIT;

Hat die Archivtabelle eine andere Struktur (Klartext statt Fremdschlüssel, berechnete Werte), wird im SELECT gejoint und gerechnet:

INSERT INTO Kurs_Archiv (KursNr, Titel, Trainer, AnzahlBuchungen)
SELECT k.KursNr, k.Titel, t.Name, COUNT(b.BuchungNr)
FROM   Kurs k
  LEFT JOIN Trainer t ON t.TrainerNr = k.TrainerNr
  LEFT JOIN Buchung b ON b.KursNr   = k.KursNr
WHERE  k.KursNr = 12
GROUP BY k.KursNr, k.Titel, t.Name;

DB-06 · Datenbank-Theorie: ACID, Transaktion, Integrität, Index, NoSQL Meistens

Vorkommen: 6/9 · Prüfungen: S22, W22, S23, W23, W24, W25 · meist Teil 1

Transaktion und ACID

Eine Transaktion ist eine Folge von Datenbankoperationen, die als logische Einheit ganz oder gar nicht ausgeführt wird. START TRANSACTION beginnt sie, COMMIT macht die Änderungen dauerhaft, ROLLBACK nimmt alle Änderungen seit Beginn zurück.

Beispiel: Ein Mitglied wird von Kurs A nach Kurs B umgebucht (DELETE der alten + INSERT der neuen Buchung). Fällt nach dem DELETE der Server aus, wäre das Mitglied ohne Transaktion in gar keinem Kurs mehr.

Referenzielle Integrität

Jeder Fremdschlüsselwert muss als Primärschlüsselwert in der referenzierten Tabelle existieren (oder NULL sein, wenn erlaubt). Das DBMS verhindert daher

• das Einfügen/Ändern eines FK-Werts, zu dem es keinen PK gibt (Buchung für Mitglied 99, das nicht existiert),
• das Löschen/Ändern eines PK-Werts, auf den noch FKs zeigen – oder reagiert gemäß der festgelegten Regel:

FOREIGN KEY (TrainerNr) REFERENCES Trainer (TrainerNr) ON DELETE SET NULL

Index

Ein Index ist eine zusätzliche, sortierte Datenstruktur (meist ein B-Baum) über eine oder mehrere Spalten – vergleichbar mit dem Stichwortverzeichnis eines Buches. Ohne Index muss das DBMS bei einer Suche die ganze Tabelle lesen (Full Table Scan).

Sinnvoll für Spalten, die oft in WHERE, JOIN (Fremdschlüssel!) oder ORDER BY vorkommen, bei großen Tabellen und Spalten mit vielen verschiedenen Werten. Wenig sinnvoll bei kleinen Tabellen, bei Spalten mit wenigen verschiedenen Werten (z. B. ja/nein) und bei Tabellen mit sehr vielen Schreibzugriffen. Der Primärschlüssel ist automatisch indiziert.

CREATE INDEX idx_buchung_datum ON Buchung (Datum);

Redundanz und Anomalien

Siehe DB-02. Ergänzung: Gewollte Redundanz gibt es z. B. in Archiv- und Auswertungstabellen (Data Warehouse), bei bewusster Denormalisierung für schnellere Abfragen und bei Datensicherungen.

NoSQL und dokumentenorientierte Datenbanken

NoSQL („not only SQL“) bezeichnet Datenbanken ohne festes Tabellenschema. Arten: Dokumentenorientiert (JSON-Dokumente, z. B. MongoDB), Key-Value (Schlüssel → Wert, z. B. Cache, Sitzungsdaten), spaltenorientiert (Wide Column, sehr große verteilte Datenmengen), Graph (Knoten und Kanten, z. B. soziale Netze, Routen).

Einbettung vs. Referenz am Beispiel „Mitglied mit Buchungen“:

{
  "_id": 1,
  "vorname": "Anna",
  "nachname": "Berg",
  "ort": "Bonn",
  "buchungen": [
    { "datum": "2026-03-02", "kurs": "Yoga" },
    { "datum": "2026-03-04", "kurs": "Spinning" }
  ]
}

// Collection "mitglieder"
{ "_id": 1, "vorname": "Anna",
  "nachname": "Berg", "ort": "Bonn" }

// Collection "buchungen"
{ "_id": 1, "mitgliedId": 1,
  "kursId": 10, "datum": "2026-03-02" }

JSON-Regeln: Objekt { "schlüssel": wert, … }, Array [ wert, wert ]; Schlüssel und Strings in doppelten Anführungszeichen; Zahlen, true, false, null ohne; kein Komma nach dem letzten Element; Datum als String.

DB-07 · SQL: Unterabfragen Oft

Vorkommen: 5/9 · Prüfungen: W21, S22, W22, W23, S26 · Teil 2, Aufgabe 4

Eine Unterabfrage (Subquery) ist ein SELECT in Klammern innerhalb einer anderen Anweisung (SELECT, UPDATE, DELETE, INSERT).

Vergleich mit einem Aggregat – Kurse, die teurer sind als der Durchschnitt:

SELECT Titel, Preis
FROM   Kurs
WHERE  Preis > (SELECT AVG(Preis) FROM Kurs);

IN – Mitglieder, die Spinning (Kurs 11) gebucht haben:

SELECT Nachname
FROM   Mitglied
WHERE  MitgliedNr IN (SELECT MitgliedNr FROM Buchung WHERE KursNr = 11);

NOT EXISTS – Mitglieder ohne jede Buchung:

SELECT m.Nachname
FROM   Mitglied m
WHERE  NOT EXISTS (SELECT * FROM Buchung b WHERE b.MitgliedNr = m.MitgliedNr);

Korreliert oder nicht korreliert?

• Nicht korreliert: Die Unterabfrage ist unabhängig von der äußeren Abfrage, wird einmal ausgewertet und das Ergebnis verwendet (Beispiele AVG und IN oben).
• Korreliert: Die Unterabfrage verweist auf eine Spalte der äußeren Abfrage (z. B. m.MitgliedNr) und wird gedanklich für jede Zeile der äußeren Abfrage neu ausgeführt (Beispiel NOT EXISTS oben).

Korreliertes Beispiel – die jeweils letzte Buchung jedes Mitglieds:

SELECT b.BuchungNr, b.MitgliedNr, b.Datum
FROM   Buchung b
WHERE  b.Datum = (SELECT MAX(b2.Datum)
                  FROM   Buchung b2
                  WHERE  b2.MitgliedNr = b.MitgliedNr)
ORDER BY b.MitgliedNr;

Unterabfrage in FROM – „Wie viele Buchungen hat der meistgebuchte Kurs?“ (Aggregat über ein Aggregat):

SELECT MAX(Anzahl) AS Maximum
FROM   (SELECT KursNr, COUNT(*) AS Anzahl
        FROM   Buchung
        GROUP BY KursNr) AS tbl;

Alternative zu NOT IN/NOT EXISTS: LEFT JOIN … WHERE rechts.PK IS NULL (alle linken Zeilen ohne Partner).

DB-08 · SQL: DDL (CREATE, ALTER, DROP, INDEX) Oft

Vorkommen: 5/9 · Prüfungen: W21, S22, W22, W25, S26 · Teil 2, Aufgabe 3/4

SQL-Teilsprachen und CRUD

CRUD (Create, Read, Update, Delete) sind die vier Grundoperationen auf Daten: Create → INSERT, Read → SELECT, Update → UPDATE, Delete → DELETE – also alles DML. (Nicht verwechseln: CREATE TABLE und DROP TABLE sind DDL.)

Datentypen

CREATE TABLE mit Einschränkungen (Constraints)

CREATE TABLE Kurs (
  KursNr      INTEGER      NOT NULL,
  Titel       VARCHAR(30)  NOT NULL UNIQUE,
  TrainerNr   INTEGER,                          -- darf NULL sein
  Preis       DECIMAL(5,2) NOT NULL DEFAULT 8.00,
  MaxPlaetze  INTEGER      CHECK (MaxPlaetze > 0),
  PRIMARY KEY (KursNr),
  FOREIGN KEY (TrainerNr) REFERENCES Trainer (TrainerNr)
);

Reihenfolge: Die referenzierte Tabelle (Trainer) muss vorher existieren; beim Löschen mit DROP TABLE umgekehrt. Der Datentyp des FK muss zum PK passen. Zusammengesetzter PK: PRIMARY KEY (MitgliedNr, KursNr, Datum).

ALTER TABLE, DROP, CREATE INDEX

ALTER TABLE Mitglied ADD COLUMN Email VARCHAR(80);
ALTER TABLE Mitglied DROP COLUMN Ort;
ALTER TABLE Mitglied MODIFY COLUMN Nachname VARCHAR(60) NOT NULL;   -- MySQL
ALTER TABLE Mitglied ADD CONSTRAINT uq_mitglied_email UNIQUE (Email);
ALTER TABLE Kurs ADD FOREIGN KEY (TrainerNr) REFERENCES Trainer (TrainerNr);
DROP TABLE Buchung_Alt;
CREATE INDEX idx_mitglied_nachname ON Mitglied (Nachname);

Spalte aus vorhandenen Daten ableiten (Muster aus W25): neue Spalte anlegen → per UPDATE mit Textfunktion füllen → ggf. alte Spalte löschen. Beispiel: Die ersten zwei Zeichen eines Mitgliedscodes wie 'BN-2024-001' geben den Standort an:

ALTER TABLE Mitglied ADD COLUMN Standort CHAR(2);
UPDATE Mitglied SET Standort = LEFT(Mitgliedscode, 2);     -- oder SUBSTRING(Mitgliedscode, 1, 2)

Textfunktionen (MySQL): LEFT(t, n), RIGHT(t, n), SUBSTRING(t, start, länge) (Zählung ab 1), LENGTH(t), CONCAT(t1, t2, …), UPPER(t)/LOWER(t), TRIM(t).

DB-09 · SQL: UNION Sonstige

Vorkommen: 1/9 · Prüfung: S24 (T2 4d, 12 P)

UNION hängt die Ergebnisse zweier SELECT-Anweisungen untereinander (ein JOIN verbindet dagegen nebeneinander).

• Beide SELECTs brauchen die gleiche Anzahl Spalten mit kompatiblen Datentypen in gleicher Reihenfolge.
• Die Spaltennamen des Ergebnisses kommen aus dem ersten SELECT.
• ORDER BY steht nur einmal ganz am Ende und sortiert das Gesamtergebnis.

SELECT Nachname AS Name, 'Mitglied' AS Rolle FROM Mitglied WHERE Ort = 'Bonn'
UNION
SELECT Name, 'Trainer' FROM Trainer
ORDER BY Name;

Typisches Muster: aktuelle Tabelle + Archivtabelle gemeinsam auswerten. Soll über die vereinigte Menge gruppiert werden, kommt die UNION in eine Unterabfrage in FROM:

SELECT Jahr, COUNT(*) AS Anzahl
FROM   (SELECT YEAR(Datum) AS Jahr FROM Buchung
        UNION ALL
        SELECT YEAR(Datum) FROM Buchung_Archiv) AS alle
GROUP BY Jahr
ORDER BY Jahr;

Sind die Gruppen in den beiden Tabellen sicher getrennt (z. B. alle alten Jahre nur im Archiv), kann man auch jede Tabelle einzeln gruppieren und die beiden Gruppenergebnisse mit UNION ALL verbinden. Überschneiden sich die Gruppen, entstehen dabei aber zwei Ergebniszeilen für dieselbe Gruppe.

DB-10 · SQL: Benutzer und Rechte (CREATE USER, GRANT, REVOKE) Sonstige

Vorkommen: 1/9 · Prüfung: S23 (T2 4d, 4 P)

CREATE USER rezeption IDENTIFIED BY 'Passwort';           -- MySQL genauer: 'rezeption'@'localhost'
GRANT SELECT, INSERT, UPDATE ON fitness.Mitglied TO rezeption;
GRANT SELECT ON fitness.Kurs TO rezeption;                  -- je Tabelle ein GRANT (oder fitness.* für alle)
REVOKE UPDATE ON fitness.Mitglied FROM rezeption;

CREATE ROLE trainer_rolle;                                 -- Rolle = Bündel von Rechten
GRANT SELECT ON fitness.* TO trainer_rolle;
GRANT trainer_rolle TO lisa;                               -- Benutzer erhält die Rolle
DROP USER rezeption;

• Rollen bündeln Rechte für eine Tätigkeit (z. B. „Rezeption“). Neue Mitarbeiter bekommen nur die Rolle; ändern sich die Anforderungen, wird nur die Rolle angepasst → weniger Aufwand, weniger Fehler, besser nachvollziehbar.
• Anwendungsbenutzer: Eine Web-Anwendung verbindet sich mit einem eigenen DB-Benutzer, der nur die benötigten DML-Rechte hat – nie mit dem Administrator (root) und ohne DDL-Rechte.

DB-11 · Trigger, Stored Procedure, View Sonstige

Vorkommen: 1/9 · Prüfung: S22 (T2 4aa/4ab, je 2 P)

CREATE VIEW v_kursuebersicht AS
SELECT k.Titel, t.Name AS Trainer, k.Preis
FROM   Kurs k
  LEFT JOIN Trainer t ON t.TrainerNr = k.TrainerNr;

DELIMITER //
CREATE PROCEDURE kurs_buchen(IN p_mitglied INT, IN p_kurs INT)
BEGIN
  INSERT INTO Buchung (MitgliedNr, KursNr, Datum)
  VALUES (p_mitglied, p_kurs, CURDATE());
END //
DELIMITER ;
CALL kurs_buchen(4, 12);

CREATE TRIGGER trg_preis_protokoll
AFTER UPDATE ON Kurs
FOR EACH ROW
INSERT INTO Preis_Log (KursNr, PreisAlt, PreisNeu, Zeitpunkt)
VALUES (OLD.KursNr, OLD.Preis, NEW.Preis, NOW());

Ein BEFORE-Trigger kann eine Änderung auch verhindern, in MySQL mit SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = '…'. DELIMITER ist nur im MySQL-Client nötig, damit das Semikolon im Rumpf die Anweisung nicht vorzeitig beendet.

DB-12 · Datenqualität beim Import von Altdaten Sonstige

Vorkommen: 1/9 · Prüfung: W24 (T2 3b, 13 P)

Kriterien der Datenqualität

Typische Probleme manuell gepflegter Altdaten

Beispiel: Mitgliederliste eines Sportvereins (Excel):

ETL und Vorgehen beim Import

ETL = Extract (Daten aus der Quelle lesen, z. B. CSV-Export der Excel-Datei) – Transform (bereinigen, vereinheitlichen, aufteilen, Dubletten zusammenführen, Schlüssel zuordnen, prüfen) – Load (in die Zieltabellen laden, Reihenfolge der Fremdschlüssel beachten).

1. Analyse (Profiling): Formate, Leerwerte, Ausreißer und Dubletten feststellen und zählen.
2. Zielstruktur festlegen (Tabellen in 3NF, Datentypen).
3. Rohdaten unverändert in eine Staging-Tabelle laden (alle Spalten als Text).
4. Transformationsregeln festlegen und per Skript/SQL anwenden: Datum parsen, Felder aufteilen, Zuordnungstabellen für Schreibweisen („Fussball“ → „Fußball“), Zahlen normieren.
5. Nicht automatisch lösbare Fälle in eine Fehlerliste → manuelle Klärung durch die Fachabteilung.
6. Prüfen: Plausibilitätsregeln, Stichproben, Summen-/Anzahlabgleich; erst Testimport, dann produktiver Import.

Bewertung: Lohnt sich der Import?

Abzuwägen sind Aufwand (Datenmenge, Fehlerquote, Anteil manueller Nacharbeit) und Nutzen (Bedeutung der Historie für Auswertungen, Gewährleistung, gesetzliche Aufbewahrungspflichten, Risiko falscher Daten im neuen System). Mögliche Ergebnisse: vollständiger Import nach Bereinigung, Teilimport (z. B. nur Stammdaten oder nur die letzten Jahre) oder kein Import (Altdaten schreibgeschützt archivieren, Neuerfassung).

B · Belegsatz

Enthält nur, was dir auch die IHK beilegen würde: Notationshilfen und Anlagen (Ausgangssituation, Tabellen, Formulare, Texte). Keine Erklärungen. Tipp: Diesen Teil separat ausdrucken und beim Lösen daneben legen.

Notationshilfen

Entity-Relationship-Modell (ER-Modell)

SQL-Syntax (Auszug)

Anlagen

C · Aufgaben

Alle Aufgaben beziehen sich auf die Ausgangssituation in Anlage 1. SQL-Anweisungen in Standard-SQL/MySQL wie im Belegsatz. Gehen Sie – wenn nichts anderes angegeben ist – immer vom Datenbestand in den Anlagen 2 und 3 aus (Aufgaben bauen nicht aufeinander auf).

DB-01 · ER-/Relationenmodell

DB-02 · Normalisierung

DB-03 · SQL: SELECT mit JOIN

DB-04 · SQL: Aggregatfunktionen, GROUP BY, HAVING

SELECT k.KundenNr, k.Nachname, COUNT(a.AusleiheNr) AS Anzahl
FROM   Kunde k
  LEFT JOIN Ausleihe a ON k.KundenNr = a.KundenNr
WHERE  COUNT(a.AusleiheNr) = 0
GROUP BY k.KundenNr;

DB-05 · SQL: INSERT, UPDATE, DELETE

DB-06 · Datenbank-Theorie

DB-07 · SQL: Unterabfragen

DB-08 · SQL: DDL

DB-09 · SQL: UNION

SELECT YEAR(Beginn) AS Jahr, COUNT(*), SUM(Betrag), SUM(Kilometer)
FROM   Ausleihe
GROUP BY YEAR(Beginn)
UNION ALL
SELECT YEAR(Beginn), COUNT(*), SUM(Betrag), SUM(Kilometer)
FROM   Ausleihe_Archiv
GROUP BY YEAR(Beginn)
ORDER BY Jahr;

DB-10 · SQL: Benutzer und Rechte

DB-11 · Trigger, Stored Procedure, View

CREATE PROCEDURE rueckgabe(IN p_nr INT, IN p_km INT)
BEGIN
  UPDATE Ausleihe a
    INNER JOIN Fahrrad f   ON f.FahrradNr   = a.FahrradNr
    INNER JOIN Kategorie k ON k.KategorieNr = f.KategorieNr
  SET a.Ende      = CURDATE(),
      a.Kilometer = p_km,
      a.Betrag    = (DATEDIFF(CURDATE(), a.Beginn) + 1) * k.Tagespreis
  WHERE a.AusleiheNr = p_nr
    AND a.Ende IS NULL;
END

DB-12 · Datenqualität beim Import

Originalaufgaben zum Üben

Alle Dateien liegen im Ordner Prüfungsvorbereitung. Lösungen gibt es nur für 2023 Sommer, 2023 Winter, 2024 Sommer und 2025 Winter. Den originalen SQL-Syntax-Auszug findest du in den Belegsätzen von W21, S22, W22, S24 und W25 (z. B. 2024/sommer/AE Sommer 2024 Belegsatz.pdf).