Die Druckversion wird nicht mehr unterstützt und kann Darstellungsfehler aufweisen. Bitte aktualisiere deine Browser-Lesezeichen und verwende stattdessen die Standard-Druckfunktion des Browsers.

aiMOOC

Datenbanken und betriebliche Datenmodelle – Tabellen mit eindeutigen Schlüsseln modellieren

QR-Code

Einleitung

Datenbanken und betriebliche Datenmodelle – Tabellen mit eindeutigen Schlüsseln modellieren

Zielgruppe: Ausbildung, insbesondere Fachinformatik, IT und kaufmännische Berufe

Dauer: ca. 90–120 Minuten

Praxisfall: Die fiktive Ausbildungsfirma „Lernlager“ möchte Kunden, Artikel und Aufträge zuverlässig verwalten.

Dein Lernziel: Du modellierst Tabellen, vergibst eindeutige Primärschlüssel, verknüpfst Datensätze über Fremdschlüssel und prüfst Dein Datenmodell mit SQL.

Sicherheit: Alle Übungen nutzen erfundene Daten. Der Python-Code arbeitet ausschließlich mit einer lokalen SQLite-Datenbank im Arbeitsspeicher. Es werden keine Daten an Server übertragen und keine bestehenden Datenbanken verändert.

Voraussetzung: Python 3 mit dem Standardmodul sqlite3. Keine zusätzliche Softwareinstallation durch das Skript und keine Netzwerkverbindung erforderlich.

Externe Medien: Videos, Wikipedia und LearningApps sind optionale Zusatzangebote. Beim Laden externer Inhalte können Verbindungsdaten an deren Anbieter übertragen werden. Gib dort keine echten Kunden- oder Zugangsdaten ein.

Dein Lernpfad

Lerneinheit	Inhalt	Zeit
1	Tabellen und Datensätze	5 Min.
2	Eindeutige Primärschlüssel	10 Min.
3	Fremdschlüssel und Referenzen	10 Min.
4	Beziehungen und zusammengesetzte Schlüssel	10 Min.
5	Lokale SQL-Lernwerkstatt	20 Min.
6	Fehler erkennen und Datenmodell verbessern	15 Min.
7	Interaktive Aufgaben und Lernnachweis	20–50 Min.

Lerneinheit 1: Tabellen und Datensätze

Eine relationale Datenbank speichert Informationen in Tabellen. Eine Zeile ist ein Datensatz, eine Spalte ein Attribut.

Ausbildungsfall: Die Firma „Lernlager“ verwaltet zwei fiktive Kunden.

kunde_id	name
1	Übungsfirma Blau
2	Übungsfirma Grün

Beobachte: Verschiedene Kunden erhalten unterschiedliche IDs. Auch zwei Kunden mit gleichem Namen müssen eindeutig unterscheidbar bleiben.

Basisaufgabe: Zeichne eine Tabelle „artikel“ mit den Spalten artikel_id und bezeichnung.

Feedback: Gut modelliert ist die Tabelle, wenn jede Artikelzeile genau einen Artikel beschreibt und eine eindeutige ID besitzt.

Lerneinheit 2: Primärschlüssel eindeutig festlegen

Ein Primärschlüssel (PRIMARY KEY) identifiziert einen Datensatz eindeutig. Seine Werte dürfen nicht doppelt vorkommen; fachlich muss die Identifikation dauerhaft zuverlässig bleiben.

Ungeeignet: Kundenname – verschiedene Kunden können denselben Namen besitzen.

Geeignet: kunde_id – eine stabile, eindeutig vergebene Kennung.

CREATE TABLE kunde (
    kunde_id INTEGER PRIMARY KEY,
    name TEXT NOT NULL
);

Merke: INTEGER PRIMARY KEY sorgt in SQLite für eine eindeutige ganzzahlige Kennung. Die Beispiele verwenden ausdrücklich gesetzte IDs.

Basisaufgabe: Warum wäre „name“ kein sicherer Primärschlüssel?

Begründetes Feedback: Namen können mehrfach auftreten oder sich verändern. Eine künstlich vergebene, stabile ID trennt die Identität des Kunden von seinen veränderlichen Eigenschaften.

Lerneinheit 3: Fremdschlüssel und Referenzen

Ein Fremdschlüssel (FOREIGN KEY) verweist auf einen geeigneten Schlüssel einer anderen Tabelle. Hier verweist auftrag.kunde_id auf kunde.kunde_id.

kunde
kunde_id – PK	name
1	Übungsfirma Blau
2	Übungsfirma Grün

auftrag
auftrag_id – PK	kunde_id – FK
100	1
101	1
102	2

Visualisierung:

KUNDE                  AUFTRAG

kunde_id = 1 --------> auftrag_id = 100
             \-------> auftrag_id = 101

kunde_id = 2 --------> auftrag_id = 102

Eine Kundin oder Firma:
mehrere mögliche Aufträge

Jeder Auftrag:
genau ein zugeordneter Kunde

Die Abbildung zeigt ein weiteres allgemeines Beispiel für Referenzen zwischen Datenbanktabellen.

Referentielle Integrität bedeutet: Ein gesetzter Fremdschlüssel muss auf einen vorhandenen passenden Datensatz verweisen. In unserem Modell darf ein Auftrag außerdem keinen leeren Kundenverweis besitzen.

CREATE TABLE auftrag (
    auftrag_id INTEGER PRIMARY KEY,
    kunde_id INTEGER NOT NULL
        REFERENCES kunde(kunde_id)
        ON DELETE RESTRICT
);

Wichtige SQLite-Besonderheit: Die Fremdschlüsselprüfung muss für jede neue Datenbankverbindung aktiviert werden.

PRAGMA foreign_keys = ON;

Anwendungsaufgabe: Kann Auftrag 103 auf kunde_id 999 verweisen, wenn dieser Kunde nicht existiert?

Feedback: Nein. Bei aktivierter Fremdschlüsselprüfung weist SQLite den Einfügeversuch zurück. Dadurch entsteht kein verwaister Auftrag.

Lerneinheit 4: Beziehungen zwischen Tabellen modellieren

Unterscheide Beziehungstypen:

1:1: Ein Datensatz gehört zu höchstens einem passenden Datensatz auf der anderen Seite.

1:n: Ein Kunde kann mehrere Aufträge besitzen.

n:m: Ein Auftrag kann mehrere Artikel enthalten; derselbe Artikel kann in mehreren Aufträgen vorkommen.

Die n:m-Beziehung zwischen Auftrag und Artikel lösen wir über eine zusätzliche Tabelle position auf.

KUNDE 1 ---- n AUFTRAG
                  |
                  1
                  |
                  n
               POSITION
                  n
                  |
                  1
                  |
                ARTIKEL

position
auftrag_id – FK	artikel_id – FK	menge
100	10	2
100	20	1
101	30	1
102	10	1

Zusammengesetzter Primärschlüssel:

PRIMARY KEY (auftrag_id, artikel_id)

Die Kombination ist eindeutig. Dadurch darf ein bestimmter Artikel in unserem Ausbildungsmodell pro Auftrag nur einmal als Position erscheinen. Die bestellte Stückzahl steht in „menge“.

Anwendungsaufgabe: Warum reicht artikel_id allein nicht als Primärschlüssel der Tabelle position?

Feedback: Derselbe Artikel darf in verschiedenen Aufträgen vorkommen. Erst die Kombination aus Auftrag und Artikel unterscheidet die Positionen eindeutig.

Lerneinheit 5: Lokale SQL-Lernwerkstatt

Dein Auftrag: Erstelle das vollständige Datenmodell und prüfe es mit echten SQL-Anweisungen an ausschließlich fiktiven Übungsdaten.

Start: Speichere den folgenden Python-Code lokal als „lernlager.py“ und starte ihn mit:

python3 lernlager.py

Unter Windows kann je nach Installation auch „py lernlager.py“ verwendet werden.

Vollständiges, lokal ausführbares Beispiel:

import sqlite3

SCHEMA = """
CREATE TABLE kunde (
    kunde_id INTEGER PRIMARY KEY,
    name TEXT NOT NULL
);

CREATE TABLE artikel (
    artikel_id INTEGER PRIMARY KEY,
    bezeichnung TEXT NOT NULL
);

CREATE TABLE auftrag (
    auftrag_id INTEGER PRIMARY KEY,
    kunde_id INTEGER NOT NULL
        REFERENCES kunde(kunde_id)
        ON DELETE RESTRICT
);

CREATE TABLE position (
    auftrag_id INTEGER NOT NULL
        REFERENCES auftrag(auftrag_id)
        ON DELETE RESTRICT,
    artikel_id INTEGER NOT NULL
        REFERENCES artikel(artikel_id)
        ON DELETE RESTRICT,
    menge INTEGER NOT NULL CHECK (menge > 0),
    PRIMARY KEY (auftrag_id, artikel_id)
);
"""

DATEN = """
INSERT INTO kunde VALUES
    (1, 'Übungsfirma Blau'),
    (2, 'Übungsfirma Grün');

INSERT INTO artikel VALUES
    (10, 'USB-C-Kabel'),
    (20, 'Maus'),
    (30, 'Tastatur');

INSERT INTO auftrag VALUES
    (100, 1),
    (101, 1),
    (102, 2);

INSERT INTO position VALUES
    (100, 10, 2),
    (100, 20, 1),
    (101, 30, 1),
    (102, 10, 1);
"""

def neue_testumgebung():
    db = sqlite3.connect(":memory:")
    db.execute("PRAGMA foreign_keys = ON")
    aktiv = db.execute(
        "PRAGMA foreign_keys"
    ).fetchone()[0]
    assert aktiv == 1
    db.executescript(SCHEMA + DATEN)
    return db

ABFRAGE = """
SELECT a.auftrag_id, k.name,
       ar.bezeichnung, p.menge
FROM auftrag AS a
JOIN kunde AS k
    ON k.kunde_id = a.kunde_id
JOIN position AS p
    ON p.auftrag_id = a.auftrag_id
JOIN artikel AS ar
    ON ar.artikel_id = p.artikel_id
ORDER BY a.auftrag_id, ar.artikel_id;
"""

db = neue_testumgebung()
print("AUFTRAGSLISTE")
for zeile in db.execute(ABFRAGE):
    print(zeile)

assert db.execute(
    "PRAGMA foreign_key_check"
).fetchall() == []
db.close()

TESTS = {
    "1": (
        "Gültiger Auftrag",
        "INSERT INTO auftrag VALUES (103, 2)",
        False,
        "Kunde 2 existiert."
    ),
    "2": (
        "Doppelte Kunden-ID",
        "INSERT INTO kunde VALUES (1, 'Duplikat')",
        True,
        "Der Primärschlüssel muss eindeutig sein."
    ),
    "3": (
        "Unbekannter Kunde",
        "INSERT INTO auftrag VALUES (103, 999)",
        True,
        "Der Fremdschlüssel findet keinen Kunden."
    ),
    "4": (
        "Doppelte Auftragsposition",
        "INSERT INTO position VALUES (100, 10, 1)",
        True,
        "Die Schlüsselkombination existiert bereits."
    ),
    "5": (
        "Kunde mit Aufträgen löschen",
        "DELETE FROM kunde WHERE kunde_id = 1",
        True,
        "ON DELETE RESTRICT schützt die Referenzen."
    )
}

while True:
    print("\nTESTLABOR")
    for nummer, fall in TESTS.items():
        print(nummer, "-", fall[0])
    try:
        wahl = input("Test wählen, Enter beendet: ").strip()
    except EOFError:
        break

    if wahl == "":
        break

    if wahl not in TESTS:
        print("Bitte eine gültige Testnummer wählen.")
        continue

    name, sql, fehler_erwartet, erklaerung = TESTS[wahl]
    db = neue_testumgebung()

    try:
        db.execute(sql)
    except sqlite3.IntegrityError:
        blockiert = True
    else:
        blockiert = False
    finally:
        db.close()

    korrekt = blockiert == fehler_erwartet
    print("BESTANDEN" if korrekt else "PRÜFEN")
    print("Ergebnis:", "BLOCKIERT" if blockiert
          else "AKZEPTIERT")
    print("Begründung:", erklaerung)

Warum ist diese Lernwerkstatt isoliert? Jede Datenbank wird mit „:memory:“ neu im Arbeitsspeicher angelegt. Jeder Test beginnt mit identischen Übungsdaten; nach dem Schließen der Verbindung verschwinden die Änderungen. Das Programm führt keine Netzwerkzugriffe aus.

Visualisierte SQL-Ausgabe

Die JOIN-Abfrage verknüpft vier Tabellen über ihre Schlüssel.

Auftrag	Kunde	Artikel	Menge
100	Übungsfirma Blau	USB-C-Kabel	2
100	Übungsfirma Blau	Maus	1
101	Übungsfirma Blau	Tastatur	1
102	Übungsfirma Grün	USB-C-Kabel	1

Erwartung: Das Skript gibt genau diese vier Datenzeilen aus. Danach kannst Du die fünf isolierten Testfälle interaktiv auswählen.

Lerneinheit 6: Fehler erkennen und Datenmodelle verbessern

Doppelt gespeicherte Informationen können Änderungsanomalien erzeugen. Wenn ein Kundenname an vielen Auftragsstellen getrennt gespeichert wird, können widersprüchliche Namen entstehen.

Bessere Lösung: Kundenname nur in „kunde“, Kunden-ID als Referenz in „auftrag“ verwenden.

Drei aufeinander aufbauende Praxisaufgaben

Basis: Starte Test 2. Beschreibe, warum die doppelte Kunden-ID abgewiesen wird.

Anwendung: Starte Test 3. Erkläre, welche Tabelle den Fehler verursacht und welche Beziehung geschützt wird.

Transfer: Starte Test 5. Entscheide, ob „ON DELETE RESTRICT“ für eine betriebliche Auftragsverwaltung sinnvoll ist. Begründe Deine Entscheidung.

Gestufte Hilfen

Hilfe 1 – Orientierung: Suche zuerst nach PRIMARY KEY, REFERENCES und der Spalte kunde_id.

Hilfe 2 – Struktur: Die Tabelle auftrag ist von kunde abhängig. Die Tabelle position ist von auftrag und artikel abhängig.

Hilfe 3 – Lösungshinweis: Eine neue Auftragszeile benötigt eine vorhandene Kunden-ID. Eine Position benötigt eine gültige Auftrags-ID und Artikel-ID. Die Kombination beider Positionsschlüssel darf nicht doppelt auftreten.

Begründetes Feedback

Test	Erwartung	Warum?
Gültiger Auftrag	Akzeptiert	Die referenzierte Kunden-ID existiert.
Doppelte Kunden-ID	Blockiert	PRIMARY KEY verhindert doppelte Kennungen.
Unbekannter Kunde	Blockiert	FOREIGN KEY verhindert ungültige Referenzen.
Doppelte Position	Blockiert	Der zusammengesetzte Primärschlüssel schützt die Kombination.
Kunde mit Aufträgen löschen	Blockiert	ON DELETE RESTRICT verhindert das Löschen referenzierter Elternzeilen.

Hinweis zur Übertragbarkeit: In SQLite gelten einige Besonderheiten bei PRIMARY KEY und NULL. Deshalb setzen wir Pflichtfelder ausdrücklich auf NOT NULL und verwenden für die einzelnen Tabellen-IDs INTEGER PRIMARY KEY.

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Was ist ein Datensatz in einer relationalen Tabelle? (Eine Tabellenzeile) (!Ein Datenbankserver) (!Ein Programmfenster) (!Eine Netzwerkadresse)

Welche Aufgabe hat ein Primärschlüssel? (Er identifiziert jede Tabellenzeile eindeutig) (!Er verschlüsselt automatisch sämtliche Daten) (!Er ersetzt grundsätzlich alle Tabellen) (!Er speichert ausschließlich Namen)

Welche Spalte ist im Beispiel als Primärschlüssel der Kundentabelle vorgesehen? (kunde_id) (!name) (!bezeichnung) (!menge)

In welcher Tabelle steht der Fremdschlüssel zum Kunden? (auftrag) (!artikel) (!kunde) (!Eine Fremdschlüsseltabelle ist unnötig)

Welche Wirkung hat eine aktivierte Fremdschlüsselprüfung? (Sie verhindert ungültige Verweise auf andere Datensätze) (!Sie löscht bei jedem Start alle Tabellen) (!Sie erlaubt automatisch doppelte Primärschlüssel) (!Sie ersetzt die SQL-Sprache)

Welche Beziehung besteht zwischen Kunde und Auftrag in unserem Modell? (Eins zu viele) (!Viele zu viele ohne Zwischentabelle) (!Genau eins zu eins) (!Keine Beziehung)

Welche Spalten bilden gemeinsam den Primärschlüssel von position? (auftrag_id und artikel_id) (!kunde_id und name) (!bezeichnung und menge) (!name und artikel_id)

Was bewirkt PRAGMA foreign_keys = ON in SQLite? (Es aktiviert die Prüfung von Fremdschlüsselbedingungen) (!Es erstellt automatisch alle benötigten Tabellen) (!Es deaktiviert sämtliche Prüfungen) (!Es verbindet die Datenbank mit dem Internet)

Welchen Zweck hat ein SQL JOIN? (Er verknüpft passende Datensätze mehrerer Tabellen) (!Er erzeugt automatisch neue Kundennummern) (!Er entfernt grundsätzlich alle Fremdschlüssel) (!Er verhindert jede Form von Datenspeicherung)

Was passiert beim Einfügen eines Auftrags mit unbekannter Kunden-ID in unserer Lernwerkstatt? (Der Vorgang wird durch einen Integritätsfehler verhindert) (!Der Kunde wird automatisch neu angelegt) (!Der Auftrag wird ohne Einschränkung akzeptiert) (!Sämtliche Artikel werden gelöscht)

Memory

Ordne jeweils den Fachbegriff der richtigen Bedeutung zu.

Primärschlüssel	Eindeutige Kennung einer Tabellenzeile
Fremdschlüssel	Verweis auf einen passenden anderen Datensatz
Referentielle Integrität	Sicherung gültiger Tabellenbeziehungen
Zusammengesetzter Schlüssel	Gemeinsame Identifikation durch mehrere Spalten
JOIN	Verknüpfung passender Tabellenzeilen
NOT NULL	Pflichtwert ohne leeren Datenbankwert

Drag and Drop

Ordne den Begriffen ihre Bedeutung im Ausbildungsfall zu.

Ordne die richtigen Begriffe zu.	Beschreibung
Kundentabelle	Speichert die Stammdaten einer Übungsfirma
Auftragstabelle	Speichert Vorgänge mit einem Kundenverweis
Artikeltabelle	Speichert die Bezeichnungen angebotener Produkte
Positionstabelle	Verbindet Aufträge und Artikel mit einer Menge
Fremdschlüsselprüfung	Kontrolliert die Gültigkeit vorhandener Referenzen

Kreuzworträtsel

Verwende bei Umlauten gegebenenfalls ae, oe und ue.

Primaerschluessel	Wie heißt der Schlüssel, der eine Tabellenzeile eindeutig identifiziert?
Fremdschluessel	Welcher Schlüssel stellt eine Referenz zu einer anderen Tabelle her?
Datensatz	Wie nennt man eine einzelne Zeile einer Datenbanktabelle?
Attribut	Wie heißt eine Eigenschaft, die in einer Tabellenspalte gespeichert wird?
Referenz	Wie bezeichnet man einen Verweis auf einen anderen Datensatz?
Integritaet	Welcher Begriff beschreibt die Einhaltung von Konsistenzbedingungen?

LearningApps

Optionale externe Lernangebote. Für die lokalen SQL-Tests wird LearningApps nicht benötigt.

Lückentext

In einer relationalen Datenbank werden Informationen in

gespeichert.

Eine einzelne Tabellenzeile wird als

bezeichnet.

Ein

identifiziert jede Zeile eindeutig.

Ein Verweis auf einen anderen Datensatz wird durch einen

hergestellt.

Die Sicherung gültiger Verweise gehört zur referentiellen

.

Ein Kunde kann in unserem Beispiel mehrere

besitzen.

Die Tabelle position verbindet Aufträge mit

.

Zur eindeutigen Identifikation einer Position verwenden wir einen

Primärschlüssel.

Mit der SQL-Anweisung

können passende Tabellenzeilen miteinander verknüpft werden.

SQLite aktiviert die Fremdschlüsselprüfung über den Befehl

.

Die Python-Verbindung mit :memory: erstellt eine Datenbank im

.

Offene Aufgaben

Leicht

Datenbanktabelle: Zeichne eine Tabelle für drei fiktive Artikel mit einer eindeutigen Artikel-ID und einer Bezeichnung.
Primärschlüssel: Kennzeichne in Deiner Artikeltabelle den geeigneten Primärschlüssel und begründe die Auswahl.
Datensatz: Erstelle zwei fiktive Kunden mit gleichem Namen, aber unterschiedlichen IDs. Erkläre, warum das zulässig ist.
Fremdschlüssel: Verbinde auf Papier drei fiktive Aufträge mit zwei vorhandenen Kunden.

Standard

SQL: Starte das Lernlager-Skript und dokumentiere die vier Ergebniszeilen der JOIN-Abfrage.
Referentielle Integrität: Teste einen ungültigen Kundenverweis und erkläre die Fehlermeldung anhand der Tabellenbeziehung.
Entity-Relationship-Modell: Zeichne ein kleines ER-Diagramm für Kunde, Auftrag, Position und Artikel.
Datenmodellierung: Ergänze Deine Skizze um die Kardinalitäten und begründe die Verwendung der Positionstabelle.

Schwer

Normalisierung (Datenbank): Untersuche, was passieren könnte, wenn Kundenname und Artikelbezeichnung in jeder Auftragsposition doppelt gespeichert würden.
SQL CREATE TABLE: Erweitere Deine lokale Kopie des Skripts um die fiktive Tabelle „lieferant“ mit eindeutigem Primärschlüssel.
Datenintegrität: Entwirf einen isolierten Testfall für eine ungültige Artikelreferenz und überprüfe die erwartete Zurückweisung in einer neu erstellten In-Memory-Datenbank.
Datenbankentwurf: Entwickle ein vereinfachtes Datenmodell für die fiktive Ausleihe von Arbeitsgeräten und erkläre, welche Fremdschlüssel erforderlich sind.

Lernkontrolle

Bearbeite die Aufgaben mit Begründungen, Skizzen oder lokalen Testnachweisen.

Primärschlüssel: Zwei fiktive Kunden tragen denselben Namen. Entwickle eine Datenbanklösung, die beide zuverlässig unterscheidet, und erkläre die Vorteile.
Referentielle Integrität: Ein Auftrag verweist auf einen gelöschten Kunden. Erkläre, welche betrieblichen Probleme entstehen können, und schlage eine geeignete Schutzmaßnahme vor.
Datenbanknormalisierung: Eine Firma speichert Kundenadresse und Artikelbezeichnung wiederholt in jeder Auftragszeile. Erkläre die möglichen Änderungsprobleme und entwirf eine verbesserte Tabellenstruktur.
Kardinalität (Datenbankmodellierung): Ein Auftrag enthält mehrere Artikel, und ein Artikel wird in vielen Aufträgen verwendet. Entwickle die benötigte Zwischentabelle und begründe ihre Schlüsselwahl.
SQL JOIN: Ein Ausbilder benötigt eine Übersicht aller bestellten Artikel mit zugehörigem Kundennamen. Erkläre, über welche Tabellen und Schlüssel die Daten verbunden werden müssen.
Datenbankdesign: Vergleiche ON DELETE RESTRICT mit einer möglichen kaskadierenden Löschung. Entscheide begründet, welches Verhalten für eine Auftragsverwaltung geeigneter sein könnte.

Lernnachweis

Dein Lernnachweis soll die eigenständige Anwendung zeigen, nicht nur das Auswendiglernen von Begriffen.

Datenmodell: Ein selbst gezeichnetes Schema mit mindestens vier sinnvoll verbundenen Tabellen.
Schlüssel: Eindeutig gekennzeichnete Primärschlüssel und Fremdschlüssel, einschließlich einer zusammengesetzten Schlüsseldefinition.
Implementierung: Ein lokal lauffähiges SQLite-Beispiel mit ausschließlich fiktiven Daten.
Funktionsprüfung: Dokumentierte Tests für einen gültigen Datensatz, einen doppelten Primärschlüssel und einen ungültigen Fremdschlüssel.
Abfrage: Eine funktionsfähige JOIN-Abfrage samt verständlich dargestelltem Ergebnis.
Reflexion: Eine kurze begründete Erklärung, wie das Datenmodell Fehler und unnötige Datenwiederholungen reduziert.
Sicherheit: Nachweis, dass ausschließlich eine lokale, isolierte Testumgebung verwendet wurde.

Bewertungsvorschlag: Datenmodell 30 %, SQL-Implementierung 25 %, Tests 25 %, fachliche Begründung und Sicherheit 20 %.

OERs zum Thema

Wikipedia-Grundlagen:

Geprüfte fachliche Quellen:

SQLite – Foreign Key Support: Offizielle Dokumentation zur Durchsetzung und Aktivierung von Fremdschlüsseln.
SQLite – CREATE TABLE: Offizielle Erläuterungen zu PRIMARY KEY, FOREIGN KEY, NOT NULL und weiteren Bedingungen.
Python – sqlite3: Offizielle Dokumentation zu SQLite-Verbindungen und In-Memory-Datenbanken.
Microsoft – Grundlagen des Datenbankentwurfs: Grundlagen zu Tabellen, Schlüsseln und Beziehungen.
Wikipedia – Schlüssel: Fachlicher Überblick über Primärschlüssel, Schlüsselkandidaten und Fremdschlüssel.
TIB AV-Portal – Relationales Modell, Primär- und Fremdschlüssel: Frei lizenziertes Hochschul-Lernvideo, CC BY 4.0.

Mediennachweise und Lizenzen

Die folgenden Bilddateien wurden über ihre Wikimedia-Commons-Dateiseiten überprüft. Die Lizenzangaben beziehen sich auf die jeweils genannte Datei.

Entity Relation Modell Beispiel Tabellen.png: TrutzX, CC BY-SA 4.0.
Relational Data Model.png: DallasClarke, gemeinfreies einfaches Diagramm.
Rel db.PNG: Bjelleklang, unter anderem CC BY-SA 3.0.
Entity Relationship Diagram Examples.png: Chad250, CC BY-SA 4.0.
Entity-Relationship-Modell.svg: Fleshgrinder, Public Domain.
Update anomaly.svg: Nabav, Public Domain.

Videonachweise:

InformatikEasyGoing – DB Primärschlüssel: Einführung in die Schlüsselwahl.
Sebastian Philippi – Referentielle Integrität durch Fremdschlüssel: Schutz von Datenbankbeziehungen.
Patrick Boekhoven – Beziehungen in relationalen Datenbanken: Kardinalitäten und Zwischentabellen.
iMooX.at – Constraints und referentielle Integrität: Zusätzliches frei lizenziertes Lernvideo, CC BY 4.0 laut Anbieter.

Die YouTube-Videos werden nur über den offiziellen Videoplayer eingebettet. Für die ersten drei Videos ist hier keine gesonderte freie Nachnutzungslizenz nachgewiesen. Eine Einbettung ist nicht mit einer Erlaubnis zur Weiterveröffentlichung oder Bearbeitung der Videodateien gleichzusetzen.

Bei Bearbeitungen der CC-BY-SA-Grafiken sind die Lizenzbedingungen einschließlich Namensnennung, Lizenzlink und Weitergabe unter gleichen Bedingungen zu beachten.