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 – Datenobjekte und Beziehungen erkennen

QR-Code

Datenbanken und betriebliche Datenmodelle – Datenobjekte und Beziehungen erkennen

Einleitung

In diesem Lernkurs lernst Du, aus einem einfachen betrieblichen Ablauf ein Datenmodell abzuleiten. Der Ausbildungsfall lautet:

Ein Kunde erteilt Aufträge. Ein Auftrag enthält Positionen. Jede Position verweist auf ein Teil.

Du arbeitest nur mit fiktiven Daten und einer lokalen SQLite-Datenbank. Es werden keine fremden Systeme, Produktivdatenbanken, Zugangsdaten oder echten Kundendaten benötigt.

Lernziel: Du erkennst Datenobjekte, Attribute, Primärschlüssel, Fremdschlüssel und Beziehungen und kannst daraus ein kleines relationales Datenmodell erstellen.

Das Bild zeigt beispielhaft, wie Datenobjekte und Beziehungen in einem Entity-Relationship-Diagramm dargestellt werden können. Die Datei ist auf Wikimedia Commons als Public Domain gekennzeichnet.

Ausbildungsfall: Fahrradteile-Handel

Du arbeitest in einem fiktiven Ausbildungsbetrieb, der Ersatzteile für Fahrräder verkauft.

Ein Kunde bestellt mehrere Teile. Zu jedem Auftrag werden einzelne Auftragspositionen gespeichert.

Datenobjekt	Beispiel	Typische Information
Kunde	K1001	Name, Ort
Auftrag	A5001	Datum, Kundennummer
Teil	T200	Bezeichnung, Preis
Position	P1	Auftragsnummer, Teilnummer, Menge

Die vier zentralen Datenobjekte sind also Kunde, Auftrag, Teil und Position.

Lerneinheit 1: Datenobjekte erkennen

Ein Datenobjekt beschreibt etwas, über das ein Betrieb dauerhaft Informationen speichern muss.

Im Fallbeispiel sind dies:

Kunde: bestellt Waren.
Auftrag: dokumentiert eine Bestellung.
Teil: beschreibt einen angebotenen Artikel.
Auftragsposition: verbindet Auftrag und Teil und speichert zum Beispiel die Menge.

Ein einzelner Kunde wie „Mira Sommer“ ist eine konkrete Entität. Der allgemeine Typ Kunde ist der Entitätstyp.

Das Commons-Beispiel zeigt zwei Entitätstypen und eine Beziehung. Die Datei steht unter CC0.

Lerneinheit 2: Attribute erkennen

Attribute beschreiben Eigenschaften eines Datenobjekts.

Datenobjekt	Sinnvolle Attribute
Kunde	kundennr, name, ort
Auftrag	auftragsnr, datum, kundennr
Teil	teilenr, bezeichnung, preis
Position	auftragsnr, positionsnr, teilenr, menge

Merksatz: Ein Attribut beschreibt eine Eigenschaft. Ein Datenobjekt fasst zusammengehörige Attribute zusammen.

Lerneinheit 3: Primärschlüssel

Ein Primärschlüssel identifiziert einen Datensatz eindeutig.

Beispiele:

Kunde → kundennr
Auftrag → auftragsnr
Teil → teilenr
Position → Kombination aus auftragsnr und positionsnr

Eine Bezeichnung wie „Schlauch 28 Zoll“ ist als Schlüssel ungeeignet, weil dieselbe Bezeichnung mehrfach vorkommen könnte.

Lerneinheit 4: Beziehungen erkennen

Betriebliche Aussagen lassen sich in Beziehungen übersetzen.

Ein Kunde erteilt viele Aufträge.

Daraus entsteht eine 1:n-Beziehung zwischen Kunde und Auftrag.

Ein Auftrag enthält viele Positionen.

Auch dies ist eine 1:n-Beziehung.

Ein Teil kann in vielen Positionen vorkommen.

Auch Teil zu Position ist 1:n.

Das Bild zeigt das Grundprinzip einer 1:n-Beziehung. Die Commons-Datei steht unter CC0.

Lerneinheit 5: Warum gibt es die Position?

Ein Auftrag kann mehrere Teile enthalten. Ein Teil kann außerdem in vielen verschiedenen Aufträgen vorkommen.

Zwischen Auftrag und Teil besteht deshalb fachlich eine n:m-Beziehung.

Im relationalen Modell wird diese Beziehung über das Datenobjekt Position aufgelöst:

Auftrag 1:n Position n:1 Teil

Das Bild zeigt, wie eine n:m-Beziehung durch eine Zwischentabelle in zwei 1:n-Beziehungen zerlegt wird. Die Datei steht unter CC0.

Lerneinheit 6: Das betriebliche Datenmodell

Das Modell des Ausbildungsfalls lässt sich so lesen:

Ausgangsobjekt	Beziehung	Zielobjekt	Bedeutung
Kunde	1:n	Auftrag	Ein Kunde kann mehrere Aufträge haben.
Auftrag	1:n	Position	Ein Auftrag kann mehrere Positionen enthalten.
Teil	1:n	Position	Ein Teil kann in mehreren Positionen vorkommen.

Kurzform:

Kunde → Auftrag → Position ← Teil

Dieses Commons-Beispiel zeigt ein größeres Entity-Relationship-Modell. Die Datei ist auf Wikimedia Commons unter einer freien GNU-FDL-Lizenz veröffentlicht.

Lerneinheit 7: Fremdschlüssel

Ein Fremdschlüssel speichert den Schlüssel eines anderen Datenobjekts.

Im Beispiel:

Auftrag.kundennr verweist auf Kunde.kundennr.
Position.auftragsnr verweist auf Auftrag.auftragsnr.
Position.teilenr verweist auf Teil.teilenr.

Damit wird aus einer fachlichen Beziehung eine technisch prüfbare Verbindung.

Lerneinheit 8: Visualisierte Beispieldaten

Kunde

kundennr	name	ort
K1001	Mira Sommer	Ulm
K1002	Leon Kern	Neu-Ulm

Auftrag

auftragsnr	datum	kundennr
A5001	2026-09-15	K1001
A5002	2026-09-16	K1001
A5003	2026-09-17	K1002

Teil

teilenr	bezeichnung	preis
T200	Fahrradschlauch	7.90
T201	Bremsbelag	12.50
T202	Kette	24.90

Position

auftragsnr	positionsnr	teilenr	menge
A5001	1	T200	2
A5001	2	T201	1
A5002	1	T202	1
A5003	1	T200	4

Du kannst jetzt direkt erkennen: Auftrag A5001 gehört zu Kunde K1001 und enthält zwei Positionen.

Video: ER-Modell verstehen

Das Video „Datenbanken: ER-Modell“ behandelt Entitäten, Beziehungen und die Überführung eines ER-Modells in ein relationales Datenbankmodell.

Video: SQL und relationale Datenbanken

Der deutschsprachige SQL-Komplettkurs zeigt unter anderem Tabellen, Schlüssel, Joins und ein ER-Diagramm. Für diesen Kurs reichen die Abschnitte zu Schlüsseln, Joins und ER-Modell.

Lokale Testumgebung mit SQLite

Für alle folgenden Beispiele genügt eine lokale SQLite-Installation. Arbeite ausschließlich mit der fiktiven Datei ausbildung.db.

Im Terminal:

sqlite3 ausbildung.db

Aktiviere anschließend die Prüfung von Fremdschlüsseln:

PRAGMA foreign_keys = ON;

Diese Übungsdaten bleiben lokal auf Deinem Rechner.

Codebeispiel 1: Tabellen lokal anlegen

CREATE TABLE kunde (
    kundennr TEXT PRIMARY KEY,
    name TEXT NOT NULL,
    ort TEXT NOT NULL
);

CREATE TABLE auftrag (
    auftragsnr TEXT PRIMARY KEY,
    datum TEXT NOT NULL,
    kundennr TEXT NOT NULL,
    FOREIGN KEY (kundennr) REFERENCES kunde(kundennr)
);

CREATE TABLE teil (
    teilenr TEXT PRIMARY KEY,
    bezeichnung TEXT NOT NULL,
    preis REAL NOT NULL CHECK (preis >= 0)
);

CREATE TABLE position (
    auftragsnr TEXT NOT NULL,
    positionsnr INTEGER NOT NULL,
    teilenr TEXT NOT NULL,
    menge INTEGER NOT NULL CHECK (menge > 0),
    PRIMARY KEY (auftragsnr, positionsnr),
    FOREIGN KEY (auftragsnr) REFERENCES auftrag(auftragsnr),
    FOREIGN KEY (teilenr) REFERENCES teil(teilenr)
);

Beobachtung: Die Fremdschlüssel bilden die Beziehungen des Datenmodells technisch ab.

Codebeispiel 2: Fiktive Daten einfügen

INSERT INTO kunde VALUES
('K1001', 'Mira Sommer', 'Ulm'),
('K1002', 'Leon Kern', 'Neu-Ulm');

INSERT INTO auftrag VALUES
('A5001', '2026-09-15', 'K1001'),
('A5002', '2026-09-16', 'K1001'),
('A5003', '2026-09-17', 'K1002');

INSERT INTO teil VALUES
('T200', 'Fahrradschlauch', 7.90),
('T201', 'Bremsbelag', 12.50),
('T202', 'Kette', 24.90);

INSERT INTO position VALUES
('A5001', 1, 'T200', 2),
('A5001', 2, 'T201', 1),
('A5002', 1, 'T202', 1),
('A5003', 1, 'T200', 4);

Codebeispiel 3: Beziehungen mit JOIN sichtbar machen

SELECT
    a.auftragsnr,
    k.name AS kunde,
    p.positionsnr,
    t.bezeichnung,
    p.menge
FROM auftrag a
JOIN kunde k
    ON a.kundennr = k.kundennr
JOIN position p
    ON a.auftragsnr = p.auftragsnr
JOIN teil t
    ON p.teilenr = t.teilenr
ORDER BY a.auftragsnr, p.positionsnr;

Erwartete Ausgabe:

Auftrag	Kunde	Position	Teil	Menge
A5001	Mira Sommer	1	Fahrradschlauch	2
A5001	Mira Sommer	2	Bremsbelag	1
A5002	Mira Sommer	1	Kette	1
A5003	Leon Kern	1	Fahrradschlauch	4

Codebeispiel 4: Lokal mit Python testen

Dieses Beispiel nutzt nur die Python-Standardbibliothek und eine lokale In-Memory-Datenbank.

import sqlite3

db = sqlite3.connect(":memory:")
db.execute("PRAGMA foreign_keys = ON")

db.executescript("""
CREATE TABLE kunde (
    kundennr TEXT PRIMARY KEY,
    name TEXT NOT NULL
);

CREATE TABLE auftrag (
    auftragsnr TEXT PRIMARY KEY,
    kundennr TEXT NOT NULL,
    FOREIGN KEY (kundennr) REFERENCES kunde(kundennr)
);

INSERT INTO kunde VALUES ('K1001', 'Mira Sommer');
INSERT INTO auftrag VALUES ('A5001', 'K1001');
""")

for zeile in db.execute("""
    SELECT auftrag.auftragsnr, kunde.name
    FROM auftrag
    JOIN kunde
      ON auftrag.kundennr = kunde.kundennr
"""):
    print(zeile)

db.close()

Erwartete Ausgabe:

('A5001', 'Mira Sommer')

Die Daten existieren nur während der Programmausführung.

Isolierte Testaufgabe: Fremdschlüssel prüfen

Teste lokal:

INSERT INTO auftrag
VALUES ('A5999', '2026-09-30', 'K9999');

Wenn PRAGMA foreign_keys = ON aktiv ist, wird der Datensatz abgewiesen, weil Kunde K9999 nicht existiert.

Warum ist das sinnvoll? Ein Auftrag ohne vorhandenen Kunden würde die referentielle Integrität verletzen.

Gestufte Hilfen

Hilfe 1 – leicht: Suche zuerst nach Hauptwörtern im Geschäftsprozess: Kunde, Auftrag, Teil.

Hilfe 2 – mittel: Frage bei jedem Objekt: „Welche eindeutige Nummer identifiziert genau einen Datensatz?“

Hilfe 3 – stark: Formuliere Beziehungen als Satz: „Ein Kunde hat viele Aufträge.“ Das Wort „viele“ weist meist auf die n-Seite.

Hilfe 4 – Lösungsidee: Wenn eine Beziehung eigene Attribute besitzt, kann daraus ein eigenes Datenobjekt werden. Die Position besitzt zum Beispiel die Menge.

Basisaufgabe mit Feedback

Aufgabe: Ordne „Name“, „Kundennummer“, „Ort“ dem passenden Datenobjekt zu.

Begründetes Feedback: Alle drei Attribute gehören zu Kunde, weil sie eine konkrete Kundin oder einen konkreten Kunden beschreiben. Die Kundennummer eignet sich zusätzlich als Schlüssel, weil sie eindeutig sein soll.

Anwendungsaufgabe mit Feedback

Aufgabe: Ein Auftrag enthält drei verschiedene Teile. Wie viele Positionsdatensätze werden mindestens benötigt?

Begründetes Feedback: Es werden mindestens drei Positionen benötigt. Jede Position verbindet genau einen Auftrag mit genau einem Teil und kann zusätzlich die bestellte Menge speichern.

Transferaufgabe mit Feedback

Aufgabe: Der Betrieb möchte künftig Lieferanten erfassen. Ein Lieferant kann mehrere Teile liefern, und ein Teil kann von mehreren Lieferanten bezogen werden. Welcher Beziehungstyp liegt vor?

Begründetes Feedback: Zwischen Lieferant und Teil liegt eine n:m-Beziehung vor. Im relationalen Modell wäre deshalb eine zusätzliche Zuordnungstabelle sinnvoll, beispielsweise lieferant_teil mit Fremdschlüsseln auf beide Tabellen.

Fachliche Quellen und Medienrechte

Die fachlichen Grundlagen wurden mit folgenden öffentlich zugänglichen Quellen abgeglichen:

Entity-Relationship-Modell: Entitätstypen, Beziehungen, Kardinalitäten und ER-Diagramme.
Relationale Datenbank: Tabellen, Tupel, Attribute, Schlüssel und relationale Modellierung.
Datenbankmodell: Struktur, Operationen und Integritätsbedingungen eines Datenbankmodells.

Verwendete Medien stammen von Wikimedia Commons. Die eingebundenen Dateien sind dort als Public Domain, CC0 oder freie GNU-FDL-Datei gekennzeichnet. Die YouTube-Videos werden ausschließlich über ihre öffentlich bereitgestellten YouTube-Seiten eingebettet.

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Welches Datenobjekt beschreibt eine betriebliche Bestellung? (Auftrag) (!Kunde) (!Teil) (!Ort)

Welches Attribut eignet sich im Beispiel als Primärschlüssel für Kunde? (Kundennummer) (!Name) (!Ort) (!Bestellmenge)

Welche Beziehung besteht zwischen Kunde und Auftrag? (1 zu n) (!1 zu 1) (!n zu m ohne Zwischentabelle) (!Keine Beziehung)

Welches Datenobjekt verbindet Auftrag und Teil? (Position) (!Kunde) (!Ort) (!Preis)

Was speichert ein Fremdschlüssel? (Einen Schlüsselwert eines verbundenen Datensatzes) (!Immer einen Preis) (!Nur freien Text) (!Eine komplette Tabelle)

Warum ist Position ein eigenes Datenobjekt? (Weil die Beziehung eigene Informationen wie Menge besitzt) (!Weil jeder Kunde nur eine Position haben darf) (!Weil ein Teil keine Nummer besitzt) (!Weil SQL keine Beziehungen unterstützt)

Welche Aussage beschreibt Teil zu Position korrekt? (Ein Teil kann in vielen Positionen vorkommen) (!Ein Teil darf nur einmal verkauft werden) (!Eine Position enthält immer viele Teile) (!Teil und Position sind dasselbe Datenobjekt)

Was verhindert ein aktiv geprüfter Fremdschlüssel? (Einen Verweis auf einen nicht vorhandenen Datensatz) (!Jede doppelte Bezeichnung) (!Jede SELECT-Abfrage) (!Jede Preisänderung)

Welche SQL-Operation verbindet passende Zeilen mehrerer Tabellen? (JOIN) (!DROP) (!VACUUM) (!PRAGMA)

Welche Daten dürfen in der lokalen Übungsumgebung verwendet werden? (Fiktive Übungsdaten) (!Echte Kundendaten ohne Freigabe) (!Fremde Zugangsdaten) (!Ungefragt kopierte Produktivdaten)

Memory

Kunde	bestellt Aufträge
Auftrag	enthält Positionen
Teil	beschreibt einen Artikel
Position	verbindet Auftrag mit Teil
Primärschlüssel	identifiziert einen Datensatz eindeutig
Fremdschlüssel	verweist auf einen anderen Datensatz

Drag and Drop

Ordne die richtigen Begriffe zu.	Thema
Kundennummer	Primärschlüssel der Kundentabelle
Auftragsnummer	Primärschlüssel der Auftragstabelle
Teilnummer	Primärschlüssel der Teiletabelle
Position	Zwischenelement zwischen Auftrag und Teil
Menge	Attribut einer Auftragsposition

Kreuzworträtsel

Kunde	Welches Datenobjekt erteilt im Ausbildungsfall einen Auftrag?
Auftrag	Wie heißt die betriebliche Bestellung im Datenmodell?
Position	Welches Datenobjekt verbindet Auftrag und Teil?
Attribut	Wie heißt eine Eigenschaft eines Datenobjekts?
Relation	Wie nennt man im relationalen Modell eine tabellarisch dargestellte Beziehung von Tupeln?
Schlüssel	Welcher Begriff bezeichnet ein Merkmal zur eindeutigen Identifikation?

LearningApps

Lückentext

Ein betrieblich relevantes Objekt wie Kunde oder Auftrag wird als

modelliert. Eine Eigenschaft eines solchen Objekts heißt

. Ein Datensatz wird durch einen

eindeutig identifiziert. Ein Verweis auf einen Datensatz einer anderen Tabelle wird als

bezeichnet. Zwischen Kunde und Auftrag besteht im Ausbildungsfall eine

. Die Verbindung zwischen Auftrag und Teil wird durch die

abgebildet. Die Position kann zusätzliche Informationen wie die

speichern. SQL kann zusammengehörige Daten mit einem

verbinden.

Offene Aufgaben

Leicht

Datenobjekt erkennen: Markiere in dem Satz „Kunde Neumann bestellt zwei Fahrradketten“ die möglichen Datenobjekte.
Attribute bestimmen: Notiere je drei sinnvolle Attribute für Kunde, Auftrag und Teil.
Schlüssel finden: Begründe, warum eine Kundennummer als Schlüssel besser geeignet ist als ein Kundenname.
Beziehung formulieren: Formuliere die Beziehung zwischen Kunde und Auftrag in beiden Richtungen.

Standard

ER-Modell erstellen: Zeichne für Kunde, Auftrag, Position und Teil ein eigenes einfaches ER-Diagramm.
Kardinalität bestimmen: Ergänze für jede Beziehung die passende Kardinalität und begründe sie.
SQLite: Lege die vier Tabellen lokal an und füge mindestens zwei weitere fiktive Kunden ein.
SQL JOIN: Formuliere eine Abfrage, die Kunde, Auftrag, Teil und Menge gemeinsam ausgibt.

Schwer

Datenmodell erweitern: Ergänze das Modell um Lieferant und eine geeignete Beziehung zu Teil.
Referentielle Integrität: Erzeuge lokal absichtlich einen ungültigen Fremdschlüssel und dokumentiere die Fehlermeldung.
Geschäftsregel: Entwirf eine zusätzliche CHECK-Bedingung für einen sinnvollen Wertebereich und begründe sie.
Datenmodell vergleichen: Vergleiche zwei mögliche Modelle für Lieferant und Teil und entscheide begründet, welches Redundanzen besser vermeidet.

Lernkontrolle

Modellierungsentscheidung: Ein Auftrag kann ohne Position angelegt werden, darf aber erst mit mindestens einer Position freigegeben werden. Erkläre, welcher Teil davon durch das Datenmodell und welcher durch Anwendungslogik geprüft werden könnte.
Transfer auf Lagerwesen: Entwickle aus „Ein Lagerort enthält viele Teile; ein Teil kann an mehreren Lagerorten liegen“ ein relationales Teilmodell.
Fehleranalyse: In einer Tabelle Auftrag stehen Kundennamen statt Kundennummern. Analysiere zwei mögliche Nachteile dieses Entwurfs.
Änderungsfall: Ein Kunde zieht in einen anderen Ort. Erkläre, warum die Trennung von Kunde und Auftrag die Änderung erleichtert.
Beziehungsanalyse: Ein Teil kommt in 800 Auftragspositionen vor. Erkläre, warum die Teilbezeichnung trotzdem nur einmal in der Tabelle Teil gespeichert werden sollte.
Entwurfsbegründung: Begründe, warum Menge besser in Position als in Auftrag oder Teil gespeichert wird.

Lernnachweis

Für einen Lernnachweis zu diesem Thema solltest Du zeigen können, dass Du:

Datenobjekte in einem betrieblichen Ablauf erkennst.
sinnvolle Attribute zuordnest.
Primärschlüssel und Fremdschlüssel unterscheidest.
1:1-, 1:n- und n:m-Beziehungen fachlich erklären kannst.
eine n:m-Beziehung durch ein verbindendes Datenobjekt auflösen kannst.
das Modell Kunde–Auftrag–Position–Teil zeichnen und erklären kannst.
einfache lokale SQLite-Tabellen mit Schlüsseln erstellen kannst.
eine JOIN-Abfrage zur Darstellung verbundener Daten formulieren kannst.
referentielle Integrität anhand eines Beispiels erklären kannst.
ausschließlich fiktive oder ausdrücklich freigegebene Daten in Übungsumgebungen verwendest.