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 über Beziehungen verbinden

QR-Code

Datenbanken und betriebliche Datenmodelle – Tabellen über Beziehungen verbinden

Zielgruppe: Berufliche Ausbildung, insbesondere Fachinformatik, kaufmännische IT-Berufe und IT-nahe Ausbildungsberufe

Niveau: Grundlagen bis Anwendung

Lernzeit: ca. 60–90 Minuten

Lernform: Kurze Lerneinheiten, Grafiken, Videos, SQL-Labor und interaktive Aufgaben

Einleitung

Wie hängen Aufträge, Artikel und Auftragspositionen in einer betrieblichen Datenbank zusammen?

In diesem aiMOOC lernst Du, Tabellen über Primärschlüssel und Fremdschlüssel miteinander zu verbinden und mit SQL sinnvolle betriebliche Informationen abzufragen.

Dein Ausbildungsfall: Die fiktive Fahrradwerkstatt „Lernrad“ möchte ihre Aufträge auswerten. Du unterstützt die IT-Abteilung.

Dein Ziel: Du kannst am Ende erklären, warum eine bestimmte SQL-Abfrage fachlich sinnvoll ist, sie selbst ausführen und ihre Ergebnisse überprüfen.

Sicheres Lernen: Alle praktischen Daten sind erfunden. Das SQL-Labor läuft ausschließlich lokal im Arbeitsspeicher Deines Computers. Es benötigt weder Internet noch Datenbankserver, Zugangsdaten oder echte Kundendaten. Verwende keine fremden Systeme, Unternehmensdatenbanken oder Produktivdaten.

Lernpfad

Einheit	Lernziel	Zeit
1. Daten verstehen	Tabellen und Schlüssel erkennen	8 Minuten
2. Beziehungen modellieren	Fachliche Zusammenhänge herstellen	8 Minuten
3. Tabellen verbinden	INNER JOIN und LEFT JOIN unterscheiden	12 Minuten
4. Daten auswerten	Fehlende Werte und Summen erklären	10 Minuten
5. SQL-Labor	Selbstständig ausprobieren und überprüfen	20–30 Minuten

Lerneinheit 1: Daten verstehen

Schlüssel verbinden Informationen

Merksatz: Ein Primärschlüssel identifiziert einen Datensatz eindeutig. Ein Fremdschlüssel verweist auf einen Schlüssel einer anderen Tabelle.

Ein Fremdschlüssel ist nicht automatisch eindeutig: Mehrere Datensätze können auf denselben Auftrag verweisen.

Medienimpuls: Betrachte die Grafik. Suche die Werte, über die Informationen aus zwei Tabellen zusammengeführt werden.

Ausbildungsfall: Werkstatt Lernrad

Tabelle auftrag

id (PK)	bezeichnung
101	Fahrradcheck
102	Zubehörpaket
103	Geplanter Auftrag

Tabelle artikel

id (PK)	name	preis_eur
1	Kette	25
2	Lampe	12
3	Schloss	30

Tabelle position

id (PK)	auftrag_id (FK)	artikel_id (FK)	menge
1	101	1	2
2	101	2	1
3	102	2	3

PK bedeutet Primärschlüssel. FK bedeutet Fremdschlüssel.

Denkfrage: Warum erscheint die Auftragsnummer 101 in der Tabelle position zweimal?

Feedback: Auftrag 101 enthält zwei verschiedene Positionen. Das ist kein Datenfehler, sondern Ausdruck einer Eins-zu-viele-Beziehung.

Lerneinheit 2: Fachliche Beziehungen modellieren

Vom Geschäftsprozess zum Datenmodell

Eine Auftragsposition gehört zu genau einem Auftrag und verweist auf genau einen Artikel.

Ein Auftrag kann dagegen mehrere Positionen enthalten. Derselbe Artikel kann in mehreren Positionen unterschiedlicher Aufträge vorkommen.

AUFTRAG (1) ----- (n) POSITION (n) ----- (1) ARTIKEL

auftrag.id                position.auftrag_id
artikel.id                position.artikel_id

Fachlicher Zusammenhang:

Auftrag: Beschreibt einen betrieblichen Vorgang.
Auftragsposition: Ordnet dem Auftrag einen Artikel und eine Menge zu.
Artikel: Speichert Produktinformationen und den Beispielpreis.

Zwischen Aufträgen und Artikeln entsteht so eine Viele-zu-viele-Beziehung, die durch die Tabelle position aufgelöst wird.

Das ER-Modell verstehen

Die Grafik veranschaulicht eine betriebliche Eins-zu-viele-Beziehung. Vergleiche die Struktur mit der Beziehung zwischen Auftrag und Auftragsposition.

Videovertiefung: ER-Modell in Tabellen überführen

Mini-Auftrag: Zeichne drei Rechtecke mit den Namen auftrag, position und artikel. Markiere Primärschlüssel, Fremdschlüssel und die beiden 1:n-Beziehungen.

Feedback: Die Fremdschlüssel befinden sich in der Tabelle position, weil jede Position einem Auftrag und einem Artikel zugeordnet wird.

Lerneinheit 3: Tabellen mit SQL verbinden

INNER JOIN

Der INNER JOIN liefert Zeilen, für die die Verknüpfungsbedingung erfüllt ist.

SELECT a.id, t.name, p.menge
FROM auftrag AS a
INNER JOIN position AS p
  ON a.id = p.auftrag_id
INNER JOIN artikel AS t
  ON p.artikel_id = t.id
ORDER BY a.id, p.id;

Ergebnis:

Auftrag	Artikel	Menge
101	Kette	2
101	Lampe	1
102	Lampe	3

Beobachtung: Auftrag 103 fehlt, weil noch keine Position zugeordnet ist.

Wichtig: Ein JOIN kann mehrere Ergebniszeilen zu einem Auftrag erzeugen. Die Kreisdiagramme sind nur vereinfachte Merkhilfen und zeigen diese Zeilenvervielfachung nicht.

LEFT JOIN

Der LEFT JOIN erhält alle Zeilen der linken Tabelle, auch wenn keine passende Zeile rechts existiert.

SELECT a.id, p.id AS positions_id
FROM auftrag AS a
LEFT JOIN position AS p
  ON a.id = p.auftrag_id
ORDER BY a.id, p.id;

Ergebnis:

Auftrag	Position
101	1
101	2
102	3
103	NULL

NULL bedeutet, dass an dieser Stelle kein Wert vorhanden ist. Es bedeutet nicht die Zahl Null.

Merksatz: INNER JOIN zeigt passende Verbindungen. LEFT JOIN zeigt auch Datensätze links ohne passenden Partner rechts.

JOIN-Arten vergleichen

Video: SQL JOINs für Fachinformatiker

Für diesen Kurs sind besonders die Abschnitte ab 02:14 zu INNER JOIN und ab 14:04 zu LEFT JOIN relevant.

Entscheidungsfrage: Du sollst alle Werkstattaufträge anzeigen, auch solche ohne Position. Welchen JOIN verwendest Du?

Feedback: LEFT JOIN ist passend, wenn auftrag die linke Tabelle ist. Ein INNER JOIN würde Aufträge ohne passende Position ausschließen.

Lerneinheit 4: Betriebliche Daten auswerten

Aufträge ohne Position finden

SELECT a.id
FROM auftrag AS a
LEFT JOIN position AS p
  ON a.id = p.auftrag_id
WHERE p.id IS NULL
ORDER BY a.id;

Ergebnis: Auftrag 103.

Warum? Der LEFT JOIN erhält Auftrag 103. Mit IS NULL werden ausschließlich Aufträge ohne passende Position ausgewählt.

Fehlerquelle: Eine Bedingung auf der rechten Tabelle innerhalb von WHERE kann beim LEFT JOIN ungewollt Zeilen ohne Treffer entfernen. Bedingungen in ON und WHERE haben bei äußeren Joins unterschiedliche Auswirkungen.

Auftragswerte berechnen

SELECT a.id,
       COALESCE(SUM(p.menge * t.preis_eur), 0) AS euro
FROM auftrag AS a
LEFT JOIN position AS p
  ON a.id = p.auftrag_id
LEFT JOIN artikel AS t
  ON p.artikel_id = t.id
GROUP BY a.id
ORDER BY a.id;

Ergebnis:

Auftrag	Berechnung	Euro
101	2 × 25 + 1 × 12	62
102	3 × 12	36
103	keine Position	0

GROUP BY fasst Zeilen nach Aufträgen zusammen. SUM berechnet die Summe. COALESCE ersetzt hier das fehlende Summenergebnis durch 0.

Die Preise sind fiktiv. Steuern, Rabatte und historische Preisänderungen werden in diesem vereinfachten Ausbildungsmodell nicht berücksichtigt.

Lerneinheit 5: Lokales SQL-Labor

Deine isolierte Testumgebung

Du benötigst Python 3 mit dem standardmäßig enthaltenen Modul sqlite3.

Erstelle auf Deinem eigenen Computer die Datei sql_labor.py.
Kopiere den folgenden vollständigen Python-Code hinein.
Starte ihn im Terminal mit python3 sql_labor.py oder unter Windows mit py sql_labor.py.
Gib Deine SQL-Abfragen jeweils in einer Zeile ein.
Schreibe hilfe für gestufte Hinweise oder ende zum Beenden.

Sicherheitskonzept: Die Verbindung verwendet :memory:. Es wird keine Datenbankdatei geöffnet und keine Netzwerkverbindung hergestellt. Nach dem Einrichten wird die Verbindung auf lesenden Zugriff gestellt. Das Labor akzeptiert ausschließlich SELECT-Abfragen.

import sqlite3

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

db.executescript("""
CREATE TABLE auftrag (
 id INTEGER PRIMARY KEY,
 bezeichnung TEXT NOT NULL
);
CREATE TABLE artikel (
 id INTEGER PRIMARY KEY,
 name TEXT NOT NULL,
 preis_eur INTEGER NOT NULL
);
CREATE TABLE position (
 id INTEGER PRIMARY KEY,
 auftrag_id INTEGER NOT NULL REFERENCES auftrag(id),
 artikel_id INTEGER NOT NULL REFERENCES artikel(id),
 menge INTEGER NOT NULL CHECK(menge > 0)
);

INSERT INTO auftrag VALUES
 (101, 'Fahrradcheck'),
 (102, 'Zubehoerpaket'),
 (103, 'Geplanter Auftrag');

INSERT INTO artikel VALUES
 (1, 'Kette', 25),
 (2, 'Lampe', 12),
 (3, 'Schloss', 30);

INSERT INTO position VALUES
 (1, 101, 1, 2),
 (2, 101, 2, 1),
 (3, 102, 2, 3);
""")

db.execute("PRAGMA query_only = ON")

aufgaben = [
 (
  "Basis: Zeige Auftrags-ID und Artikel-ID je Position.",
  [(101, 1), (101, 2), (102, 2)],
  [
   "Beginne mit auftrag AS a und position AS p.",
   "Verbinde a.id mit p.auftrag_id durch INNER JOIN.",
   "Waehle a.id und p.artikel_id; ORDER BY a.id, p.id."
  ],
  "Auftrag 101 besitzt zwei Positionen. Erwartet: 3 Zeilen."
 ),
 (
  "Anwendung: Finde Auftrags-IDs ohne Position.",
  [(103,)],
  [
   "Der Auftrag ohne Position muss erhalten bleiben.",
   "Verwende LEFT JOIN zwischen auftrag und position.",
   "Pruefe WHERE p.id IS NULL; ORDER BY a.id."
  ],
  "INNER JOIN verliert Auftrag 103; NULL mit IS NULL pruefen."
 ),
 (
  "Transfer: Berechne den Euro-Gesamtwert je Auftrag.",
  [(101, 62), (102, 36), (103, 0)],
  [
   "Multipliziere p.menge mit t.preis_eur.",
   "Verbinde auftrag, position, artikel mit LEFT JOIN.",
   "Nutze SUM, GROUP BY a.id und COALESCE(..., 0)."
  ],
  "Erwartet: 101=62, 102=36 und 103=0."
 )
]

print("Offline-SQL-Labor: hilfe oder ende eingeben.")

try:
 for titel, erwartet, hilfen, feedback in aufgaben:
  print("\n" + titel)
  stufe = 0
  while True:
   try:
    sql = input("SQL> ").strip()
   except EOFError:
    raise SystemExit

   if sql.lower() == "ende":
    raise SystemExit

   if sql.lower() == "hilfe":
    print(hilfen[min(stufe, 2)])
    stufe += 1
    continue

   if not sql.upper().startswith("SELECT "):
    print("Nur SELECT-Abfragen sind erlaubt.")
    continue

   try:
    ergebnis = db.execute(sql).fetchall()
   except sqlite3.Error as fehler:
    print("SQL-Fehler:", fehler)
    continue

   print("Ergebnis:", ergebnis)

   if ergebnis == erwartet:
    print("Richtig: Die erwarteten Zeilen stimmen.")
    break

   print("Noch nicht richtig:", feedback)

 print("\nGeschafft! Begruende jetzt Deine JOIN-Wahl.")
finally:
 db.close()

Hinweis zur Lernkontrolle: Der automatische Test vergleicht die Ergebniszeilen und ihre Reihenfolge. Er beweist nicht, dass jede mögliche Abfrage fachlich korrekt formuliert ist. Begründe Deine JOIN-Bedingung deshalb zusätzlich.

Basisaufgabe: Tabellen verbinden

Auftrag: Gib Auftrags-ID und Artikel-ID für jede Position aus, sortiert nach Auftrag und Position.

Musterabfrage zur Kontrolle:

SELECT a.id, p.artikel_id
FROM auftrag AS a
INNER JOIN position AS p
  ON a.id = p.auftrag_id
ORDER BY a.id, p.id;

Erwartetes Ergebnis: (101, 1), (101, 2), (102, 2).

Begründetes Feedback: Drei Positionen ergeben drei Zeilen. Auftrag 101 erscheint zweimal, weil er zwei Positionen hat.

Anwendungsaufgabe: Fehlende Positionen

Auftrag: Finde alle Auftragsnummern ohne Position.

Musterabfrage zur Kontrolle:

SELECT a.id
FROM auftrag AS a
LEFT JOIN position AS p
  ON a.id = p.auftrag_id
WHERE p.id IS NULL
ORDER BY a.id;

Erwartetes Ergebnis: (103,).

Begründetes Feedback: Auftrag 103 ist vorhanden, aber keine Position verweist auf ihn. Der LEFT JOIN erhält den Auftrag, IS NULL erkennt die fehlende Position.

Transferaufgabe: Auftragswert

Auftrag: Berechne die Werte aller Aufträge einschließlich des noch leeren Auftrags.

Musterabfrage zur Kontrolle:

SELECT a.id,
       COALESCE(SUM(p.menge * t.preis_eur), 0)
FROM auftrag AS a
LEFT JOIN position AS p
  ON a.id = p.auftrag_id
LEFT JOIN artikel AS t
  ON p.artikel_id = t.id
GROUP BY a.id
ORDER BY a.id;

Erwartetes Ergebnis: (101, 62), (102, 36), (103, 0).

Begründetes Feedback: SUM berechnet den Positionswert je Auftrag. Beide LEFT JOINs erhalten auch den Auftrag ohne Position; COALESCE ersetzt dessen fehlendes Summenergebnis durch 0.

Lokale Datenbank mit Python verstehen

Optionales Video: SQLite in Python

Betrachte insbesondere die Abschnitte zur Datenbankverbindung, zu CREATE TABLE und SELECT.

Wichtig: Das Video ist eine zusätzliche Erklärung. Verwende für praktische Versuche ausschließlich die lokale, fiktive Übungsdatenbank dieses Kurses.

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Was kennzeichnet einen Primärschlüssel? (Er identifiziert einen Datensatz eindeutig) (!Er verschlüsselt alle Inhalte) (!Er zeigt immer einen Artikelnamen) (!Er ersetzt jede Beziehung)

Welches Feld verbindet in unserem Modell eine Position mit ihrem Auftrag? (position.auftrag_id) (!artikel.name) (!auftrag.bezeichnung) (!artikel.preis_eur)

Warum erscheint Auftrag 101 nach einem JOIN zweimal? (Weil zwei Positionen zugeordnet sind) (!Weil alle Aufträge doppelt gespeichert sind) (!Weil INNER JOIN immer verdoppelt) (!Weil ein Fremdschlüssel eindeutig sein muss)

Welche JOIN-Art erhält auch den Auftrag ohne Position? (LEFT JOIN von auftrag zu position) (!INNER JOIN von auftrag zu position) (!CROSS JOIN ohne Bedingung) (!Nur ein JOIN zwischen position und artikel)

Welcher Wert erscheint bei einer nicht vorhandenen rechten Position nach einem LEFT JOIN? (NULL) (!Immer die Zahl Null) (!Automatisch die Auftragsnummer) (!Immer ein leerer Text)

Welche Bedingung verknüpft die Auftragstabelle fachlich richtig mit der Positionstabelle? (a.id = p.auftrag_id) (!a.id = p.artikel_id) (!a.id = p.menge) (!a.bezeichnung = p.id)

Wie findest Du Aufträge ohne passende Position? (LEFT JOIN und WHERE p.id IS NULL) (!INNER JOIN und WHERE p.id IS NULL) (!ORDER BY ohne JOIN) (!GROUP BY ohne Datenquelle)

Wofür benötigst Du GROUP BY bei der Berechnung der Auftragswerte? (Für eine Zusammenfassung je Auftrag) (!Zum Löschen doppelter Primärschlüssel) (!Zum Verbinden mit dem Internet) (!Zum automatischen Erstellen von Fremdschlüsseln)

Was bewirkt COALESCE im Beispiel der Auftragswerte? (Es ersetzt eine fehlende Summe durch Null als Zahl) (!Es multipliziert alle Artikelpreise) (!Es löscht nicht bestellte Artikel) (!Es ersetzt den Primärschlüssel)

Welche Testumgebung ist für die Aufgaben vorgesehen? (Eine lokale SQLite Datenbank mit fiktiven Daten) (!Eine fremde Produktionsdatenbank) (!Ein unbekannter öffentlich zugänglicher SQL Server) (!Ein echter Kundendatenbestand)

Memory

Primärschlüssel	Eindeutige Kennung eines Datensatzes
Fremdschlüssel	Verweis auf einen Schlüssel einer anderen Tabelle
INNER JOIN	Verbindung mit passenden Datensätzen
LEFT JOIN	Erhalt aller Zeilen der linken Tabelle
ON	Bedingung für die Verknüpfung
GROUP BY	Gruppierung für zusammengefasste Ergebnisse
COALESCE	Auswahl des ersten nicht fehlenden Werts

Drag and Drop

Ordne die richtigen Begriffe zu.	Bedeutung
Auftrag	Betrieblicher Vorgang mit mehreren möglichen Positionen
Artikel	Produkt mit Name und Preis
Position	Zuordnung von Artikel und Menge zu einem Auftrag
INNER JOIN	Nur Datensätze mit passenden Verbindungen
LEFT JOIN	Alle linken Datensätze einschließlich nicht zugeordneter Zeilen
Fremdschlüssel	Gespeicherter Verweis auf eine andere Tabelle

Kreuzworträtsel

SQLite	Welche Datenbank-Engine nutzt das lokale Labor?
Auftrag	Wie heißt ein betrieblicher Vorgang, der mehrere Positionen haben kann?
Position	Welche Tabellenzeile verbindet einen Auftrag mit einem Artikel?
Artikel	Welcher Datensatz enthält Produktname und Produktpreis?
Join	Wie heißt die SQL-Operation zum Verknüpfen von Tabellen?
Fremdschluessel	Wie heißt ein Schlüssel, der auf einen anderen Datensatz verweist?

LearningApps

Optionale Online-Ergänzung: Die folgende Suche kann weitere Lernaktivitäten anzeigen. Diese sind nicht Teil des geprüften lokalen SQL-Labors. Verwende sie nur nach entsprechender Freigabe und ohne persönliche oder betriebliche Daten.

Lückentext

In einer relationalen Datenbank werden Informationen häufig in mehreren

gespeichert.

Ein

identifiziert einen Datensatz eindeutig.

Ein

stellt einen Verweis auf einen Schlüssel einer anderen Tabelle her.

Die Tabelle position enthält die Zuordnung zwischen Auftrag und

.

Ein Auftrag kann mehrere

besitzen.

Die Beziehung zwischen einem Auftrag und seinen Positionen ist eine

.

Mit SQL lassen sich Daten aus mehreren Tabellen durch einen

verbinden.

Der

liefert nur passende Verbindungen.

Der

erhält alle Zeilen der linken Tabelle.

Fehlende Werte werden in SQL durch

dargestellt.

Auf fehlende Werte prüfst Du mit dem Ausdruck

.

Mit

können die Daten je Auftrag zusammengefasst werden.

Die Funktion

berechnet eine Summe.

Mit

lässt sich ein fehlender Summenwert ersetzen.

Im lokalen Python-Labor kommt die Datenbank-Engine

zum Einsatz.

}

Offene Aufgaben

Leicht

Tabellen: Erstelle eine farbige Skizze der drei Tabellen aus dem Ausbildungsfall und markiere alle Schlüssel.
Primärschlüssel: Erkläre anhand eines selbst gewählten Beispiels, warum jede Position eine eindeutige ID benötigt.
Fremdschlüssel: Zeichne Verbindungspfeile von den Fremdschlüsseln der Positionstabelle zu den zugehörigen Primärschlüsseln.
SQL: Führe die Basisabfrage im lokalen Labor aus und dokumentiere das Ergebnis mit einem Screenshot ohne persönliche Daten.

Standard

INNER JOIN: Entwirf eine eigene Abfrage, die alle bestellten Artikelnamen und Mengen ausgibt.
LEFT JOIN: Vergleiche die Ergebnisse von INNER JOIN und LEFT JOIN und erkläre den Unterschied anhand von Auftrag 103.
Entity-Relationship-Modell: Erstelle ein eigenes ER-Modell für eine fiktive Bibliothek mit Büchern und Ausleihen.
Datenvisualisierung: Erstelle aus den berechneten Auftragswerten ein Balkendiagramm und beschreibe, welche Aussage daraus möglich ist.

Schwer

Datenbankmodellierung: Erweitere die fiktive Datenbank um Lieferanten und modelliere die dazugehörigen Beziehungen.
SQL-Abfrage: Entwickle eine Abfrage, die Artikel ohne Auftragsposition findet, und begründe Deine JOIN-Richtung.
Datenintegrität: Untersuche in einer selbst erstellten lokalen Testdatenbank, welche Folgen ein ungültiger Fremdschlüssel hätte und wie aktivierte Fremdschlüsselregeln dies verhindern.
Datenanalyse: Entwirf eine fiktive betriebliche Entscheidungssituation, für die mehrere verknüpfte Tabellen ausgewertet werden müssen. Entwickle die Abfrage und begründe, warum sie fachlich korrekt ist.

Gestufte Hilfen und begründetes Feedback

Stufe 1 – Verstehen: Welche Information suchst Du und in welchen Tabellen wird sie gespeichert?

Stufe 2 – Verbinden: Über welche Primär- und Fremdschlüssel lassen sich diese Informationen sinnvoll zuordnen?

Stufe 3 – Umsetzen: Wähle INNER JOIN oder LEFT JOIN, formuliere ON und überprüfe die erwartete Anzahl von Ergebniszeilen.

Kompetenzstufe	Erfolgsmerkmal	Feedback mit Begründung
Basis	Richtige Join-Spalten, drei Positionen	Wenn Auftrag 101 zweimal erscheint, ist das korrekt, weil er zwei Positionen besitzt.
Anwendung	Auftrag 103 wird erkannt	LEFT JOIN und IS NULL sind notwendig, damit der Auftrag ohne Position ausgewertet werden kann.
Transfer	Werte 62, 36 und 0	Die Berechnung braucht beide Tabellenbeziehungen, eine Gruppierung und die Behandlung des fehlenden Summenwertes.

Selbstprüfung: Begründe bei jedem Ergebnis, ob eine zusätzliche Zeile, eine fehlende Zeile oder ein NULL-Wert durch das betriebliche Datenmodell erklärbar ist.

Lernkontrolle

Geschäftsprozess: Eine neue Auftragsposition soll einem bestehenden Auftrag zugeordnet werden. Erkläre, welche Schlüssel verwendet werden müssen und warum.
SQL-Join: Zwei Auszubildende verwenden für dieselbe Aufgabe unterschiedliche JOIN-Arten. Entwickle einen Testfall, in dem die Ergebnisse voneinander abweichen, und erkläre die Ursache.
Datenmodell: Ein Betrieb speichert Artikelnamen direkt in jeder Auftragsposition. Analysiere mögliche Nachteile dieser Lösung und begründe, weshalb eine eigene Artikeltabelle hilfreich sein kann.
Fehleranalyse: Eine LEFT-JOIN-Abfrage liefert nicht alle Aufträge. Entwickle eine mögliche Ursache durch eine WHERE-Bedingung und schlage eine begründete Verbesserung vor.
Transferleistung: Plane ein relationales Datenmodell für eine fiktive Ausbildungswerkstatt, die Geräte und Reparaturen dokumentiert. Begründe Deine Tabellen, Schlüssel und Beziehungen.
Datensicherheit: Begründe, warum neue SQL-Abfragen zuerst mit fiktiven Daten in einer lokalen Testumgebung geprüft werden sollten.

Lernnachweis

Für Deinen Lernnachweis sollst Du zeigen, dass Du den fachlichen Zusammenhang zwischen Datenmodell und SQL-Abfrage verstanden hast.

Eine beschriftete Darstellung der Tabellen und ihrer Schlüssel.
Ein korrektes ER-Modell mit Beziehungstypen.
Mindestens eine selbst entwickelte INNER-JOIN-Abfrage.
Mindestens eine selbst entwickelte LEFT-JOIN-Abfrage.
Eine Auswertung mit Gruppierung und Summenbildung.
Eine dokumentierte Gegenüberstellung von erwarteten und tatsächlich erhaltenen Ergebnissen.
Eine Erklärung mindestens eines typischen JOIN-Fehlers.
Eine kurze Reflexion über die sichere Verwendung lokaler Testdaten.

Bewertungsvorschlag: Fachlich sinnvolles Datenmodell 25 %, SQL-Abfragen 30 %, Ergebnisprüfung und Begründungen 30 %, sichere und nachvollziehbare Durchführung 15 %.

OERs zum Thema

Wikipedia: Join (SQL)

Fachlich geprüfte Referenzen:

SQLite-Dokumentation: SELECT und JOIN – offizielle SQL-Referenz, einschließlich INNER JOIN, LEFT JOIN und ON/WHERE.
SQLite-Dokumentation: Foreign Keys – offizielle Beschreibung der Fremdschlüsselregeln und ihrer Aktivierung.
Python-Dokumentation: sqlite3 – lokale SQLite-Verbindungen und Datenbanken im Arbeitsspeicher.
Wikipedia: Join (SQL) – Überblick über JOIN-Operationen.
Wikimedia Commons: SQL Joins – zusätzliche lizenzierte Visualisierungen.

Mediennachweise und Nutzungsrechte

Die folgenden Bilder wurden auf Wikimedia Commons anhand der jeweiligen Dateibeschreibungen und Lizenzangaben ausgewählt.

Relational key.svg – Urheber LionKimbro; gemeinfrei.
Entity Relationship Diagram Examples.png – Urheber Chad250; CC BY-SA 4.0.
Relational DB Example ER Diagram Corporation.svg – Urheber Fishpi; gemeinfrei.
SQL Join - 07 A Inner Join B.svg – Urheber GermanX; CC BY-SA 4.0.
SQL Join - 01 A Left Join B.svg – Urheber GermanX; CC BY-SA 4.0.
SQL Joins.svg – Urheber Arbeck; CC BY 3.0.

Lizenzen:

CC BY-SA 4.0

CC BY 3.0

Die Grafiken werden unverändert eingebunden. Die vereinfachten JOIN-Kreisdiagramme sind keine vollständige Darstellung relationaler Zeilenmultiplizitäten.

YouTube-Medien:

ER-Modell ins Relationenmodell überführen – Lernspur.
SQL JOINs für Fachinformatiker – Dozenten aus Leidenschaft.
Datenbank in Python verwenden – sqlite3 – Binärverkehr.

Die YouTube-Videos sind öffentlich verfügbare, ergänzende Lernmedien. Sie werden nicht als frei lizenzierte OER ausgewiesen; die Rechte verbleiben bei den jeweiligen Rechteinhabern. Externe Video- und LearningApps-Angebote können beim Laden Verbindungsdaten an Dritte übermitteln. Beachte die Freigabe- und Datenschutzregeln Deiner Bildungseinrichtung. Das lokale SQL-Labor selbst benötigt diese Dienste nicht.