# Seite 5. Relationales Datenbankmodell **Relationales Datenbankmodell** Diese Seite erklärt das **relationale Datenbankmodell** so, dass du es schnell für IHK-Aufgaben anwenden kannst. Das relationale Datenbankmodell beschreibt, wie Daten in **Tabellen** gespeichert werden. Dabei sind besonders wichtig: ```text Tabellen Datensätze Attribute / Spalten Primärschlüssel Fremdschlüssel Beziehungen zwischen Tabellen ``` --- **Grafik 1: Grundlagen des relationalen Datenbankmodells** ![Relationales Datenbankmodell – Grundlagen](https://trainer.ulrich-wiki.com/assets/relationales-modell-grundlagen.svg) Diese Grafik zeigt dir die wichtigsten Grundbegriffe: - **Tabelle** - **Datensatz** - **Primärschlüssel** - **Fremdschlüssel** - Zusammenhang zwischen Zeilen, Spalten und Schlüsseln --- **Wofür braucht man das relationale Datenbankmodell?** Das relationale Datenbankmodell wird benutzt, um ein fachliches Datenmodell technisch näher an eine echte Datenbank zu bringen. Ein ERM zeigt zuerst fachlich: ```text Kunde gibt Bestellung auf ``` Das relationale Modell macht daraus Tabellen: ```text Kunde Bestellung ``` Und legt fest: ```text Welche Spalten gibt es? Was ist der Primärschlüssel? Wo wird ein Fremdschlüssel benötigt? Wie hängen die Tabellen zusammen? ``` --- **Woran erkenne ich in einer Aufgabe, dass ein relationales Datenbankmodell gemeint ist?** Typische Signalwörter: | Signalwort / Formulierung | Hinweis | |---|---| | Tabelle | Daten sollen tabellarisch dargestellt werden | | Datensatz | Es geht um Zeilen in einer Tabelle | | Attribut / Spalte | Es geht um Felder einer Tabelle | | Primärschlüssel | Eindeutige Kennzeichnung eines Datensatzes | | Fremdschlüssel | Verweis auf eine andere Tabelle | | Relation | Tabelle oder Beziehung zwischen Tabellen | | Normalisierung | Tabellen sollen sauber strukturiert werden | | n:m auflösen | Zwischentabelle wird benötigt | | ERM in Tabellen überführen | Relationales Modell ist gemeint | --- **Grundbegriffe** | Begriff | Bedeutung | Beispiel | |---|---|---| | **Tabelle** | Sammlung gleichartiger Datensätze | Kunde, Bestellung, Produkt | | **Datensatz** | Eine Zeile in einer Tabelle | ein bestimmter Kunde | | **Attribut / Spalte** | Eigenschaft eines Datensatzes | name, email, preis | | **Primärschlüssel** | eindeutige ID einer Tabelle | kunden_id | | **Fremdschlüssel** | Verweis auf Primärschlüssel einer anderen Tabelle | kunden_id in Bestellung | | **Relation** | Tabelle oder Beziehung zwischen Tabellen | Kunde 1:n Bestellung | --- **Tabelle** Eine Tabelle speichert gleichartige Daten. Beispiel Tabelle **Kunde**: | kunden_id | name | email | |---|---|---| | 1 | Müller | mueller@example.de | | 2 | Schmidt | schmidt@example.de | Die Tabelle hat: - Spalten - Zeilen - Datensätze - einen Primärschlüssel --- **Datensatz** Ein Datensatz ist eine einzelne Zeile in einer Tabelle. Beispiel: | kunden_id | name | email | |---|---|---| | 1 | Müller | mueller@example.de | Dieser eine Kunde ist ein Datensatz. Merksatz: **Datensatz = eine vollständige Zeile einer Tabelle** --- **Attribut / Spalte** Ein Attribut ist im relationalen Modell eine Spalte. Beispiel Tabelle **Kunde**: ```text kunden_id name email telefon ``` Diese Spalten beschreiben den Kunden genauer. Merksatz: **Attribut im ERM wird meistens zur Spalte in der Tabelle.** --- **Primärschlüssel** Ein Primärschlüssel identifiziert jeden Datensatz eindeutig. Beispiel: ```text kunden_id produkt_id bestellung_id ``` Warum ist das wichtig? Namen sind nicht eindeutig. Beispiel: ```text Müller ``` kann mehrfach vorkommen. Aber: ```text kunden_id = 1 ``` ist eindeutig. Merksatz: **Jede Tabelle sollte einen Primärschlüssel haben.** --- **Fremdschlüssel** Ein Fremdschlüssel verweist auf den Primärschlüssel einer anderen Tabelle. Beispiel: Tabelle **Kunde**: | kunden_id | name | |---|---| | 1 | Müller | | 2 | Schmidt | Tabelle **Bestellung**: | bestellung_id | bestelldatum | kunden_id | |---|---|---| | 101 | 01.02.2026 | 1 | | 102 | 03.02.2026 | 1 | Hier ist: ```text kunden_id ``` in der Tabelle **Bestellung** ein Fremdschlüssel. Warum? Weil er auf die Tabelle **Kunde** verweist. ```text Bestellung.kunden_id → Kunde.kunden_id ``` --- **Grafik 2: Vom ERM zum relationalen Modell** ![Vom ERM zum relationalen Modell](https://trainer.ulrich-wiki.com/assets/relationales-modell-erm-zu-tabellen.svg) Diese Grafik zeigt: - Aus der Entität **Kunde** wird die Tabelle **Kunde** - Aus der Entität **Bestellung** wird die Tabelle **Bestellung** - Die 1:n-Beziehung wird durch einen **Fremdschlüssel** auf der n-Seite abgebildet - In der Tabelle **Bestellung** steht deshalb `kunden_id` als Fremdschlüssel --- **ERM vs. relationales Datenbankmodell** | ERM | Relationales Datenbankmodell | |---|---| | fachliches Modell | tabellarisches Modell | | zeigt Entitäten | zeigt Tabellen | | zeigt Attribute | zeigt Spalten | | zeigt Beziehungen | zeigt Fremdschlüssel | | zeigt Kardinalitäten | zeigt Schlüsselbeziehungen | | eher Planung | näher an Datenbank / SQL | Merksatz: ```text ERM = Was gibt es fachlich? Relationales Modell = Wie wird es tabellarisch gespeichert? ``` --- **Aus Entitäten werden Tabellen** Im ERM hast du zum Beispiel: ```text Kunde Bestellung Produkt ``` Im relationalen Modell werden daraus Tabellen: ```text Tabelle Kunde Tabelle Bestellung Tabelle Produkt ``` Beispiel: ```text Entität Kunde ``` wird zu: ```text Kunde(kunden_id, name, email) ``` --- **Aus Attributen werden Spalten** ERM: ```text Kunde - kunden_id - name - email ``` Relationales Modell: | kunden_id | name | email | |---|---|---| Merksatz: **Attribute werden im relationalen Modell zu Spalten.** --- **1:1-Beziehung im relationalen Modell** Beispiel: ```text Person 1 --- 1 Personalausweis ``` Mögliche Tabellen: ```text Person(person_id, name) Personalausweis(ausweis_id, ausweisnummer, person_id) ``` Hier kann `person_id` in **Personalausweis** als Fremdschlüssel gespeichert werden. Wichtig: Bei 1:1 ist fachlich zu prüfen, ob man beide Tabellen wirklich getrennt braucht. --- **1:n-Beziehung im relationalen Modell** Beispiel: ```text Kunde 1 --- n Bestellung ``` Das bedeutet: ```text Ein Kunde kann mehrere Bestellungen haben. Eine Bestellung gehört genau zu einem Kunden. ``` Tabellen: ```text Kunde(kunden_id, name, email) Bestellung(bestellung_id, bestelldatum, kunden_id) ``` Wichtig: Der Fremdschlüssel kommt auf die **n-Seite**. Also: ```text kunden_id ``` steht in: ```text Bestellung ``` Merksatz: **Bei 1:n steht der Fremdschlüssel auf der n-Seite.** --- **n:m-Beziehung im relationalen Modell** Beispiel: ```text Bestellung n --- m Produkt ``` Das bedeutet: ```text Eine Bestellung kann mehrere Produkte enthalten. Ein Produkt kann in mehreren Bestellungen vorkommen. ``` Eine n:m-Beziehung kann man nicht sauber direkt mit nur einem Fremdschlüssel abbilden. Deshalb braucht man eine Zwischentabelle. Aus: ```text Bestellung n:m Produkt ``` wird: ```text Bestellung 1:n Bestellposition n:1 Produkt ``` Tabellen: ```text Bestellung(bestellung_id, bestelldatum) Produkt(produkt_id, bezeichnung, preis) Bestellposition(bestellung_id, produkt_id, menge) ``` Die Tabelle **Bestellposition** enthält mindestens: | Spalte | Bedeutung | |---|---| | bestellung_id | Fremdschlüssel auf Bestellung | | produkt_id | Fremdschlüssel auf Produkt | | menge | Zusatzinformation zur Beziehung | --- **Warum braucht man bei n:m eine Zwischentabelle?** Beispiel: Eine Bestellung enthält mehrere Produkte. Ein Produkt kann in mehreren Bestellungen vorkommen. Zusätzlich muss man speichern: ```text Wie oft wurde ein Produkt bestellt? Welcher Preis galt zum Bestellzeitpunkt? Gab es Rabatt? ``` Diese Informationen gehören nicht nur zur Bestellung und nicht nur zum Produkt. Sie gehören zur Verbindung zwischen Bestellung und Produkt. Deshalb braucht man: ```text Bestellposition ``` --- **Typische Umwandlung von ERM zu relationalem Modell** | ERM | Relationales Modell | |---|---| | Entität | Tabelle | | Attribut | Spalte | | Primärschlüssel | Primärschlüssel | | 1:n-Beziehung | Fremdschlüssel auf n-Seite | | n:m-Beziehung | Zwischentabelle | | Kardinalität | Schlüsselbeziehung | --- **Beispiel: Kunde und Bestellung** Fachliche Beschreibung: ```text Ein Kunde kann mehrere Bestellungen aufgeben. Eine Bestellung gehört genau zu einem Kunden. ``` ERM: ```text Kunde 1 --- n Bestellung ``` Relationales Modell: ```text Kunde(kunden_id, name, email) Bestellung(bestellung_id, bestelldatum, kunden_id) ``` Erklärung: ```text kunden_id ist Primärschlüssel in Kunde. kunden_id ist Fremdschlüssel in Bestellung. ``` --- **Beispiel: Schüler und Kurs** Fachliche Beschreibung: ```text Ein Schüler kann mehrere Kurse belegen. Ein Kurs kann von mehreren Schülern belegt werden. ``` ERM: ```text Schüler n --- m Kurs ``` Relationales Modell: ```text Schüler(schueler_id, vorname, nachname) Kurs(kurs_id, kursname) Belegung(schueler_id, kurs_id, anmeldedatum) ``` Erklärung: ```text Belegung ist die Zwischentabelle. schueler_id ist Fremdschlüssel auf Schüler. kurs_id ist Fremdschlüssel auf Kurs. ``` --- **Primärschlüssel und Fremdschlüssel markieren** In der Prüfung kannst du Schlüssel zum Beispiel so kennzeichnen: ```text PK = Primary Key = Primärschlüssel FK = Foreign Key = Fremdschlüssel ``` Beispiel: ```text Kunde( kunden_id PK, name, email ) Bestellung( bestellung_id PK, bestelldatum, kunden_id FK ) ``` Oder kompakt: ```text Kunde(kunden_id PK, name, email) Bestellung(bestellung_id PK, bestelldatum, kunden_id FK) ``` --- **Zusammengesetzter Primärschlüssel** Bei Zwischentabellen kann der Primärschlüssel aus mehreren Spalten bestehen. Beispiel: ```text Belegung(schueler_id, kurs_id, anmeldedatum) ``` Hier könnten zusammen den Datensatz eindeutig machen: ```text schueler_id + kurs_id ``` Das nennt man einen **zusammengesetzten Primärschlüssel**. Alternative: Man kann auch eine eigene ID verwenden: ```text belegung_id ``` Dann sieht die Tabelle so aus: ```text Belegung(belegung_id PK, schueler_id FK, kurs_id FK, anmeldedatum) ``` Beides kann je nach Aufgabenstellung sinnvoll sein. --- **Normalisierung kurz erklärt** Normalisierung bedeutet: ```text Daten so strukturieren, dass Wiederholungen und Fehler vermieden werden. ``` Einfach gesagt: ```text Gleiche Informationen sollen nicht unnötig mehrfach gespeichert werden. ``` Schlechtes Beispiel: | bestellung_id | kundenname | kundenemail | produkt | |---|---|---|---| | 1 | Müller | mueller@example.de | Monitor | | 2 | Müller | mueller@example.de | Tastatur | Problem: ```text Kundendaten werden mehrfach gespeichert. ``` Besser: ```text Kunde(kunden_id, name, email) Bestellung(bestellung_id, kunden_id) ``` Dann stehen die Kundendaten nur einmal in der Tabelle **Kunde**. --- **Vorgehensweise in der Prüfung** Wenn du ein relationales Datenbankmodell erstellen sollst, gehe so vor: | Schritt | Frage | |---|---| | 1 | Welche Entitäten gibt es? | | 2 | Welche Tabellen entstehen daraus? | | 3 | Welche Attribute werden zu Spalten? | | 4 | Was ist der Primärschlüssel jeder Tabelle? | | 5 | Gibt es eine 1:n-Beziehung? | | 6 | Wo muss der Fremdschlüssel stehen? | | 7 | Gibt es eine n:m-Beziehung? | | 8 | Welche Zwischentabelle wird benötigt? | | 9 | Welche Zusatzattribute gehören in die Zwischentabelle? | --- **Typische IHK-Fehler** | Fehler | Warum problematisch? | |---|---| | Primärschlüssel vergessen | Datensätze sind nicht eindeutig erkennbar | | Fremdschlüssel auf falscher Seite | Beziehung wird falsch abgebildet | | n:m ohne Zwischentabelle | Relational unsauber | | Attribute doppelt speichern | führt zu Redundanz | | Entität und Attribut verwechseln | falsche Tabellenstruktur | | Zwischentabelle ohne Fremdschlüssel | Verbindung zwischen Tabellen fehlt | | Kardinalität nicht beachtet | falsche Modellierung | --- **Prüfungs-Merksätze** ```text Tabelle = Sammlung gleichartiger Datensätze Datensatz = eine Tabellenzeile Attribut = Spalte Primärschlüssel = eindeutige ID Fremdschlüssel = Verweis auf andere Tabelle 1:n = Fremdschlüssel auf der n-Seite n:m = Zwischentabelle nötig ERM = fachliche Sicht Relationales Modell = Tabellen- und Schlüssel-Sicht ``` --- **Mini-Beispiel 1** Aufgabe: ```text Ein Kunde kann mehrere Bestellungen haben. Eine Bestellung gehört genau zu einem Kunden. ``` Lösung: ```text Kunde(kunden_id PK, name, email) Bestellung(bestellung_id PK, bestelldatum, kunden_id FK) ``` Begründung: ```text 1:n-Beziehung. Der Fremdschlüssel kunden_id steht auf der n-Seite, also in Bestellung. ``` --- **Mini-Beispiel 2** Aufgabe: ```text Ein Schüler kann mehrere Kurse belegen. Ein Kurs kann von mehreren Schülern belegt werden. ``` Lösung: ```text Schüler(schueler_id PK, vorname, nachname) Kurs(kurs_id PK, kursname) Belegung(schueler_id FK, kurs_id FK, anmeldedatum) ``` Begründung: ```text n:m-Beziehung. Deshalb braucht man eine Zwischentabelle. ``` --- **Mini-Beispiel 3** Aufgabe: ```text Eine Bestellung kann mehrere Produkte enthalten. Ein Produkt kann in mehreren Bestellungen vorkommen. ``` Lösung: ```text Bestellung(bestellung_id PK, bestelldatum) Produkt(produkt_id PK, bezeichnung, preis) Bestellposition(bestellung_id FK, produkt_id FK, menge) ``` Begründung: ```text n:m-Beziehung. Bestellposition löst die Beziehung auf und speichert zusätzlich die Menge. ``` --- **Mini-Testfragen**
1. Was ist eine Tabelle? Eine Tabelle speichert gleichartige Datensätze. Beispiel: ```text Kunde Produkt Bestellung ```
2. Was ist ein Datensatz? Ein Datensatz ist eine einzelne Zeile in einer Tabelle. Beispiel: ```text kunden_id = 1, name = Müller, email = mueller@example.de ```
3. Was ist ein Primärschlüssel? Ein Primärschlüssel identifiziert jeden Datensatz eindeutig. Beispiel: ```text kunden_id produkt_id bestellung_id ```
4. Was ist ein Fremdschlüssel? Ein Fremdschlüssel verweist auf den Primärschlüssel einer anderen Tabelle. Beispiel: ```text Bestellung.kunden_id verweist auf Kunde.kunden_id ```
5. Wo steht der Fremdschlüssel bei einer 1:n-Beziehung? Der Fremdschlüssel steht auf der **n-Seite**. Beispiel: ```text Kunde 1:n Bestellung ``` Dann steht: ```text kunden_id ``` in der Tabelle: ```text Bestellung ```
6. Was braucht man bei einer n:m-Beziehung? Eine n:m-Beziehung braucht eine **Zwischentabelle**. Beispiel: ```text Schüler n:m Kurs ``` wird zu: ```text Schüler 1:n Belegung n:1 Kurs ```
7. Warum ist eine Zwischentabelle bei Bestellung und Produkt sinnvoll? Weil eine Bestellung mehrere Produkte enthalten kann und ein Produkt in mehreren Bestellungen vorkommen kann. Außerdem können Zusatzinformationen gespeichert werden: ```text menge einzelpreis rabatt ``` Diese gehören zur Verbindung zwischen Bestellung und Produkt.
8. Was bedeutet Normalisierung ganz einfach? Normalisierung bedeutet, Daten so zu strukturieren, dass unnötige Wiederholungen und Fehler vermieden werden. Merksatz: ```text Informationen möglichst nur einmal speichern. ```
--- **Nächste Seite** Danach kommt die eigene Trainer-Seite: ```text Relationales-Datenbankmodell-Trainer ``` Dort bauen wir den interaktiven Trainer mit Aufgaben zu: ```text Tabellen ableiten Primärschlüssel bestimmen Fremdschlüssel richtig platzieren 1:n-Beziehungen umsetzen n:m-Beziehungen mit Zwischentabelle auflösen ```