Kurs
In relationalen Datenbanken sind die Daten normalerweise auf mehrere Tabellen verteilt, wobei jede einen bestimmten Teil eines größeren Systems speichert. Diese Trennung ist eine gute Designentscheidung, bringt aber die Herausforderung mit sich, dass Daten schnell schwer zu interpretieren sein können.
Um dieses Problem zu lösen, nutzen relationale Datenbanken Regeln, die die Beziehungen zwischen Tabellen sicherstellen. Einer der wichtigsten Mechanismen, um diese Struktur und Zuverlässigkeit zu halten, ist die Verwendung von Fremdschlüsseln, die dafür sorgen, dass zusammengehörige Daten aufeinander abgestimmt bleiben.
In diesem Tutorial erkläre ich dir, wie Fremdschlüssel funktionieren. Wenn du als Datenbankingenieur anfängst, empfehle ich dir, unsere Kurse „Einführung in relationale Datenbanken in SQL“ und „Datenbankdesign“ zu besuchen, um zu lernen, wie du beim Definieren deines Datenbankschemas Beziehungen erstellst.
Primärschlüssel vs. Fremdschlüssel
Sowohl der Primärschlüssel, über den wir einen anderen Artikel haben, als auch der Fremdschlüssel helfen dabei, die Struktur und Integrität einer relationalen Datenbank zu halten. Ich erkläre dir beides:
Was ist ein Fremdschlüssel?
Ein Fremdschlüssel ist ein Feld oder eine Gruppe von Feldern in einer Tabelle, die auf den Primärschlüssel in einer anderen Tabelle verweisen. Dieser Fremdschlüssel verbindet Tabellen miteinander, damit die Daten in der referenzierenden Tabelle mit den gültigen Einträgen in der referenzierten Tabelle übereinstimmen.
Nehmen wir mal an, du hast eine Datenbank mit einer Tabelle „ users ” und einer Tabelle „ orders ”. Die Tabelle „ orders “ kann eine Spalte „ user_id “ haben, die mit einem vorhandenen „ user_id “ in der Tabelle „ users “ übereinstimmen muss. Die Fremdschlüsselbeschränkung sorgt dafür, dass du keine Bestellung für einen nicht existierenden Benutzer anlegen kannst.
Um Fremdschlüssel zu verstehen, muss man auch Primärschlüssel verstehen, weil Fremdschlüssel auf Primärschlüssel angewiesen sind, um diese Beziehungen aufzubauen und zu pflegen.
Was ist ein Primärschlüssel?
Ein Primärschlüssel ist eine Spalte oder eine Kombination von Spalten, die jeden Datensatz in einer Tabelle eindeutig identifiziert. Keine zwei Zeilen dürfen denselben Primärschlüsselwert haben, und dieser darf niemals „ NULL “ sein. Deshalb muss eine Tabelle einen Primärschlüssel haben, der die eindeutige Kennung ist, die auf alle Fremdschlüssel in anderen Tabellen verweist.
Die folgende Abfrage erstellt zum Beispiel die Tabelle „ users “ mit der Spalte „ user_id “ als Primärschlüssel:
-- Create users table with user_id as primary key
CREATE TABLE users (
user_id INT PRIMARY KEY,
username VARCHAR(100),
email VARCHAR(255)
);
Die wichtigsten Unterschiede zwischen Primärschlüsseln und Fremdschlüsseln
Ich hab die Unterschiede zwischen Primär- und Fremdschlüsseln in der Tabelle unten zusammengefasst:
|
Aspekt |
Primärschlüssel |
Fremdschlüssel |
|
Zweck |
Identifiziert jeden Datensatz in einer Tabelle eindeutig |
Erstellt eine Beziehung, indem auf einen Primärschlüssel in einer anderen Tabelle verwiesen wird. |
|
Einzigartigkeit |
Muss einzigartig sein |
Kann doppelte Werte haben |
|
NULL-Werte |
Darf nicht NULL sein |
Kann NULL sein (es sei denn, es gibt Einschränkungen) |
|
Ort |
In derselben Tabelle definiert |
Verweist auf den Primärschlüssel einer anderen Tabelle |
Aus der obigen Erklärung geht hervor, dass Primär- und Fremdschlüssel wichtig sind, um strukturierte und zuverlässige Datenbanken zu erstellen. Sie arbeiten zusammen, um sicherzustellen, dass die Daten konsistent sind, Beziehungen gepflegt werden und die Integrität der Datenbank erhalten bleibt.
Fremdschlüssel in SQL erstellen und verwalten
Jetzt, wo du weißt, was Fremdschlüssel sind und warum sie in Datenbanken wichtig sind, schauen wir uns an, wie du sie beim Entwerfen deiner Datenbank definieren, verwalten und steuern kannst.
Fremdschlüssel mit SQL definieren
Du kannst einen Fremdschlüssel in SQL auf zwei Arten einrichten: entweder beim Erstellen der Tabelle oder nachträglich, wenn die Tabelle schon da ist.
Das folgende Beispiel zeigt die erste Möglichkeit, wie man einen Fremdschlüssel beim Erstellen einer Tabelle in SQL Server definiert.
-- Create parent table: users
CREATE TABLE users (
user_id INT IDENTITY(1,1) PRIMARY KEY,
username NVARCHAR(100),
email NVARCHAR(255)
);
-- Create child table: orders
CREATE TABLE orders (
order_id INT IDENTITY(1,1) PRIMARY KEY,
user_id INT,
order_date DATE,
CONSTRAINT fk_orders_users FOREIGN KEY (user_id)
REFERENCES users(user_id)
);
Die Syntax ist die gleiche wie bei PostgreSQL, aber wir benutzen „ SERIAL ” für die automatische Inkrementierung des Primärschlüssels.
-- Create parent table: users
CREATE TABLE users (
user_id SERIAL PRIMARY KEY, -- SERIAL auto-increments
username VARCHAR(100),
email VARCHAR(255)
);
-- Create child table: orders
CREATE TABLE orders (
order_id SERIAL PRIMARY KEY,
user_id INT,
order_date DATE,
CONSTRAINT fk_orders_users FOREIGN KEY (user_id)
REFERENCES users(user_id)
);
Wenn du in MySQL einen Fremdschlüssel einrichtest, musst du „ InnoDB “ wie unten gezeigt verwenden.
-- Create parent table: users
CREATE TABLE users (
user_id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(100),
email VARCHAR(255)
) ENGINE=InnoDB; -- Must use InnoDB for FK support
-- Create child table: orders
CREATE TABLE orders (
order_id INT AUTO_INCREMENT PRIMARY KEY,
user_id INT,
order_date DATE,
CONSTRAINT fk_orders_users FOREIGN KEY (user_id)
REFERENCES users(user_id)
) ENGINE=InnoDB;
Wenn du eine Oracle-Datenbank benutzt, kannst du den Fremdschlüssel festlegen, aber pass auf, dass die Datentypen für beide Tabellen genau übereinstimmen.
-- Create parent table: users
CREATE TABLE users (
user_id NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
username VARCHAR2(100),
email VARCHAR2(255)
);
-- Create child table: orders
CREATE TABLE orders (
order_id NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
user_id NUMBER,
order_date DATE,
CONSTRAINT fk_orders_users FOREIGN KEY (user_id)
REFERENCES users(user_id)
);
Um einer bestehenden Tabelle einen Fremdschlüssel hinzuzufügen, benutze die folgende Abfrage:
-- Assuming orders table already exists
ALTER TABLE orders
ADD CONSTRAINT fk_orders_users
FOREIGN KEY (user_id)
REFERENCES users(user_id);
Ich empfehle dir, unsere Kurse „Einführung in SQL Server“ und „Erstellen von PostgreSQL-Datenbanken“ zu machen, um mehr über die Unterschiede zwischen den SQL-Dialekten beim Erstellen von Datenbanken zu erfahren.
Einschränkungen und Namenskonventionen verwalten
Fremdschlüssel sind eine Art von Einschränkung, eine Regel, die vom Datenbankmanagementsystem (DBMS) durchgesetzt wird, um Daten bei Vorgängen wie Einfügen, Aktualisieren und Löschen zu überprüfen. Wenn eine Fremdschlüsselbeschränkung aktiv ist, stellt die Datenbank sicher, dass jeder Wert, der in die Fremdschlüsselspalte eingegeben wird, schon in der referenzierten Primärschlüsselspalte vorhanden sein muss.
Es ist üblich, Einschränkungen nach dem Muster „ fk__ “ zu benennen. In unseren Beispielen wird der Fremdschlüssel zu „ fk_orders_users “. Wenn du deine Fremdschlüssel so benennst, macht das Schemata lesbarer, hilft beim Debuggen von Constraint-Verletzungen und funktioniert gut mit Migrationswerkzeugen. Die Validierung der Einschränkungen klappt, wenn du die folgenden Schritte machst:
-
INSERT: Lehnt eine Zeile ab, wenn der referenzierte übergeordnete Wert nicht da ist. -
UPDATE: Verhindert Änderungen, die Beziehungen kaputt machen würden. -
DELETE: Blöcke löschen Vorgänge, wenn abhängige untergeordnete Zeilen vorhanden sind.
Referenzielle Integrität und kaskadierende Aktionen
Referenzielle Integrität ist das Hauptprinzip, das durch die Fremdschlüsselbeschränkung sichergestellt wird. Fremdschlüssel helfen dabei, indem sie verwaiste Datensätze verhindern, die entstehen, wenn Zeilen in einer untergeordneten Tabelle auf nicht vorhandene Zeilen in einer übergeordneten Tabelle verweisen.
Mit SQL kannst du auch kaskadierende Aktionen einrichten. Das sind automatische Anweisungen, die dem Datenbankmanagementsystem (DBMS) genau sagen, wie es mit Änderungen an dem Datensatz, auf den verwiesen wird, umgehen soll. Du kannst diese kaskadierenden Operationen zum Beispiel für folgende Aufgaben nutzen:
|
Aktion |
Verhalten |
|
|
Untergeordnete Zeilen löschen, wenn die übergeordnete Zeile gelöscht wird |
|
|
Aktualisiere den untergeordneten Schlüssel, wenn sich der übergeordnete Schlüssel ändert. |
|
|
Der Fremdschlüssel des Kindes wird zu |
|
|
Das Kind bekommt den Standardwert. |
|
|
Verhindere Änderungen, die Beziehungen kaputt machen |
Die folgende Abfrage fügt zum Beispiel die kaskadierenden Operationen hinzu, um einen Benutzerdatensatz zu löschen, wenn er seine Bestellung storniert, und aktualisiert ihn automatisch, wenn sich seine E-Mail-Adresse user_id ändert.
-- Adds cascading rules to enforce hierarchical cleanup
ALTER TABLE orders
ADD CONSTRAINT fk_orders_users
FOREIGN KEY (user_id)
REFERENCES users(user_id)
ON DELETE CASCADE -- deleting a user deletes their orders
ON UPDATE CASCADE; -- if user_id changes, update automatically
Beziehungen zwischen Tabellen gestalten
Fremdschlüssel sind die Bausteine, die man beim Datenmodellieren benutzt, um die Beziehungen zwischen Tabellen in einer Datenbank zu definieren. In diesem Abschnitt schauen wir uns die verschiedenen Methoden an, mit denen Fremdschlüssel die Datenkonsistenz beim Verknüpfen von Tabellen sicherstellen.
Eins-zu-viele- und viele-zu-viele-Beziehungen
In einer Eins-zu-Viele-Beziehung (1:N) kann eine Zeile in einer übergeordneten Tabelle mit mehreren Datensätzen in einer untergeordneten Tabelle verbunden sein. Diese Beziehung wird hergestellt, indem der Primärschlüssel der übergeordneten Tabelle, z. B. „ users.user_id “, als Fremdschlüssel in der untergeordneten Tabelle, z. B. „ orders.customer_id “, eingefügt wird.
Zum Beispiel kann ein Nutzer mehrere Bestellungen haben oder eine Abteilung mehrere Mitarbeiter.

Beispiel für eine Eins-zu-Viele-Beziehung. Bild vom Autor.
Andererseits haben wir eine Viele-zu-Viele-Beziehung (M:N), wenn mehrere Datensätze in einer Tabelle mit mehreren Datensätzen in einer anderen Tabelle verbunden werden können. Da man eine Viele-zu-Viele-Beziehung in einer normalisierten Datenbank nicht direkt umsetzen kann, benutzen wir eine Verknüpfungstabelle (Brückentabelle), die zwei Fremdschlüssel enthält.

Beispiel für eine Viele-zu-Viele-Beziehung. Bild vom Autor.
Zusammengesetzte und selbstreferenzierende Fremdschlüssel
Ein zusammengesetzter Schlüssel besteht aus zwei oder mehr Spalten, die einen Datensatz eindeutig identifizieren und zusammen referenziert werden müssen. Dieses Muster wird verwendet, wenn der natürliche Schlüssel mehrere Felder umfasst oder wenn du doppelte Beziehungen vermeiden willst. Du hast zum Beispiel ein Kursangebot, das durch (course_id, semester) gekennzeichnet ist, oder eine Verknüpfungstabelle mit student_id und course_id als zusammengesetztem Primärschlüssel.
-- Defines courses table
CREATE TABLE course_offerings (
course_id INT,
semester VARCHAR(10),
-- Composite primary key ensures a course can only be offered once per semester
PRIMARY KEY (course_id, semester)
);
-- Create enrollment table
CREATE TABLE enrollment (
student_id INT,
course_id INT,
semester VARCHAR(10),
-- This foreign key links enrollment records to a valid course offering
FOREIGN KEY (course_id, semester)
REFERENCES course_offerings(course_id, semester)
);
Ein selbstreferenzierender Fremdschlüssel oder rekursiver Fremdschlüssel ist ein Fremdschlüssel, der auf den Primärschlüssel innerhalb derselben Tabelle verweist. Dieses Muster kommt oft bei hierarchischen Daten wie Mitarbeiter → Manager vor. So kann man rekursive Beziehungen darstellen, ohne extra Tabellen zu erstellen.
In der folgenden Abfrage verweist „ manager_id “ auf „ employee_id “ in derselben Tabelle.
CREATE TABLE employees (
employee_id INT PRIMARY KEY,
name VARCHAR(100),
-- manager_id references employee_id in the same table
manager_id INT,
FOREIGN KEY (manager_id) REFERENCES employees(employee_id)
);
Mit Daten arbeiten und Integrität sicherstellen
Wir wissen jetzt, dass Fremdschlüssel dazu da sind, die Datenintegrität in Datenbanken sicherzustellen. In diesem Abschnitt schauen wir uns die praktischen Überlegungen bei der Arbeit mit Fremdschlüsseln für SQL-Operationen, häufige Herausforderungen und die Verwaltung von Einschränkungen an.
INSERT-, UPDATE- und DELETE-Operationen
Schauen wir uns mal an, wie diese Operationen mit Fremdschlüsseln zusammenhängen.
Einfügen von Operationen mit Fremdschlüsseln
Um einen untergeordneten Datensatz einzufügen, muss der referenzierte übergeordnete Wert vorhanden sein. Wenn nicht, ist der Einsatz nicht erfolgreich. Die folgende Abfrage fügt zum Beispiel den Datensatz in die Tabelle „ orders ” ein, wenn die Tabelle „ users ” einen Datensatz enthält, bei dem „ user_id ” den Wert „ 1 ” hat.
-- users table contains user_id = 1
INSERT INTO orders (order_id, user_id, order_date)
VALUES (100, 1, '2024-02-01');
Wenn du versuchst, einen Datensatz für einen Benutzer einzufügen, der in der übergeordneten Tabelle nicht vorhanden ist, bekommst du eine Fehlermeldung, die auf eine Verletzung der Fremdschlüsselbeschränkung hinweist.
-- user_id = 999 does NOT exist in users table
INSERT INTO orders (order_id, user_id, order_date)
VALUES (101, 999, '2024-02-01');
ERROR: insert or update on table "orders" violates foreign key constraint "fk_orders_users"
Aktualisierungsvorgänge und Kaskadierungsverhalten
Updates können sich entweder auf die Fremdschlüsseltabelle oder die Primärschlüsseltabelle auswirken. Wenn du zum Beispiel den Fremdschlüssel in der Tabelle „orders“ aktualisierst, klappt das nur, wenn der Primärschlüssel in der übergeordneten Tabelle vorhanden ist. Zum Beispiel klappt das Update unten nur, wenn users.user_id = 5 exists.
-- updating foreign key value
UPDATE orders
SET user_id = 5
WHERE order_id = 100;
Aus dem obigen Beispiel geht hervor, dass du den Primärschlüssel nicht ohne eine „ ON UPDATE CASCADE “-Anweisung aktualisieren kannst, weil die untergeordneten Zeilen immer noch auf „ 1 “ verweisen. Um das zu vermeiden, löschen wir erst mal die vorhandene Fremdschlüsselbeschränkung und erstellen sie dann mit aktiviertem „ ON UPDATE CASCADE “ neu. Mit dieser Methode werden die zugehörigen Werte „ orders.user_id “ automatisch aktualisiert.
-- Drop existing foreign key constraint
ALTER TABLE orders
DROP CONSTRAINT fk_orders_users;
-- Recreate FK with ON UPDATE CASCADE enabled
ALTER TABLE orders
ADD CONSTRAINT fk_orders_users
FOREIGN KEY (user_id)
REFERENCES users(user_id)
ON UPDATE CASCADE; -- Automatically update child rows when parent key changes
UPDATE users
SET user_id = 500
WHERE user_id = 1;
Löschvorgänge und Kaskaden
Wenn du versuchst, eine übergeordnete Zeile ohne Kaskadenregel zu löschen, klappt das Löschen nicht und du kriegst eine Fehlermeldung. Wenn du eine „ ON DELETE CASCADE “-Klausel hinzufügst, wird die Datenbank angewiesen, alle zugehörigen untergeordneten Zeilen automatisch zu löschen, wenn der übergeordnete Datensatz gelöscht wird, um die Konsistenz zu gewährleisten.
Im folgenden Beispiel erstellen wir einen Fremdschlüssel für „ orders.user_id “, der auf „ users.user_id “ verweist. Mit ON DELETE CASCADE werden alle zugehörigen Bestellungen automatisch gelöscht, wenn ein Benutzer aus der Benutzertabelle gelöscht wird.
-- Add a new foreign key constraint to the orders table
ALTER TABLE orders
ADD CONSTRAINT fk_orders_users
FOREIGN KEY (user_id)
REFERENCES users(user_id)
ON DELETE CASCADE; -- Delete orders automatically when user is deleted
Manchmal willst du vielleicht, dass die Datenbank die Löschungen automatisch erledigt. Du kannst das beim Erstellen der Tabelle mit „ ON DELETE SET NULL “ durchsetzen. Dadurch werden die Fremdschlüsselspalten in der untergeordneten Tabelle auf „ NULL ” gesetzt, wenn der übergeordnete Datensatz geändert oder gelöscht wird.
CREATE TABLE orders (
order_id INT PRIMARY KEY,
user_id INT, -- FK referencing users.user_id
order_date DATE,
FOREIGN KEY (user_id)
REFERENCES users(user_id)
ON DELETE SET NULL -- If a user is deleted, set user_id in orders to NULL
);
Mit häufigen Herausforderungen umgehen
Wenn du komplexe Datenbanken entwirfst, wirst du wahrscheinlich auf Probleme mit Fremdschlüsseln stoßen. Hier sind die häufigsten Probleme, die ich mit Fremdschlüsseln hatte, und praktische Lösungen für jedes einzelne.
-
Nicht übereinstimmende Datentypen: Wenn dein Fremdschlüssel und die referenzierten Primärschlüsselspalten nicht kompatible Datentypen haben, kann die Einschränkung nicht erstellt werden. Um das zu vermeiden, solltest du die Typen in den verbundenen Tabellen immer standardisieren.
-
Zirkuläre Abhängigkeiten: Tritt auf, wenn zwei Tabellen aufeinander verweisen, was zu Einfüge-Deadlocks führen kann. Um das Problem zu lösen, solltest du das Schema-Design nochmal anschauen oder die Tabelle erst mal ohne Fremdschlüssel erstellen, die Basisdaten reinladen und dann mit „
ALTER TABLE“ die Einschränkungen hinzufügen. -
Hängende Fremdschlüssel: Dieses Problem tritt auf, wenn der Fremdschlüssel eines Kindes auf eine nicht vorhandene übergeordnete Tabelle zeigt. Um das zu beheben, kannst du kaskadierende Aktionen nutzen, um die Daten während Lösch- und Aktualisierungsvorgängen zu überprüfen.
Änderungen verwalten und Einschränkungen loswerden
Manchmal willst du vielleicht die Fremdschlüsselbeschränkungen ändern, wenn du dein Datenbankschema neu gestaltest. Hier sind ein paar Möglichkeiten, wie du den Fremdschlüssel löschen kannst, mit kleinen Unterschieden in der Syntax für die verschiedenen SQL-Dialekte.
In PostgreSQL-, SQL Server- und Oracle-Datenbanken benutzen wir die Anweisung „ DROP CONSTRAINT “.
-- Drop foreign key
ALTER TABLE orders
DROP CONSTRAINT fk_orders_users;
In MySQL benutzen wir aber die Anweisung „ DROP FOREIGN KEY “, um den Fremdschlüssel zu löschen.
-- Drop foreign key
ALTER TABLE orders
DROP FOREIGN KEY fk_orders_users;
Beachte, dass das Entfernen einer Fremdschlüsselbeschränkung dazu führt, dass die Datenbank die referenzielle Integrität nicht mehr durchsetzt. Nach dem Entfernen kannst du Daten einfügen oder aktualisieren, die gegen die Beziehung verstoßen, was zu Dateninkonsistenzen führen kann.
Leistung und Optimierung
Anhand der obigen Beispiele haben wir gesehen, wie Fremdschlüssel durch die Wahrung der Datenintegrität für ein effektives Datendesign sorgen. Du solltest aber wissen, wie du die Fremdschlüssel optimieren kannst, um die Leistung deiner Datenbanken zu verbessern. Hier sind ein paar Tipps, die ich bei der Arbeit mit Fremdschlüsseln hilfreich fand:
Indizierung und Abfrageleistung
Wenn du einen Fremdschlüssel indizierst, kann die Datenbank Änderungen während Einfüge-, Aktualisierungs- oder Löschvorgängen schnell überprüfen, indem sie die entsprechenden Schlüssel in der übergeordneten Tabelle findet. Genauso beschleunigen Indizes Join-Operationen, die untergeordnete und übergeordnete Tabellen verbinden, indem sie der Datenbank-Engine erlauben, Zeilen anhand von Fremdschlüsselwerten abzugleichen.
Als bewährte Vorgehensweise empfehle ich, Fremdschlüsselspalten explizit zu indizieren, wenn das DBMS das nicht automatisch macht.
Techniken zur Abfrageoptimierung
Einige SQL-Engines nutzen Fremdschlüssel, um Join-Eliminierung anzuwenden. Das ist eine Technik, die unnötige Joins im Abfrageausführungsplan findet und entfernt. Wenn zum Beispiel eine Abfrage nur auf Spalten aus der untergeordneten Tabelle zugreift, aber eine Verknüpfung mit einer übergeordneten Tabelle zum Filtern enthält, die durch die Fremdschlüsselbeschränkung garantiert wird, kann die Verknüpfungsoperation wegoptimiert werden.
Du kannst dir jederzeit die Ausführungspläne ansehen, um zu erfahren, wie der Abfrageoptimierer mit Fremdschlüsseln und Verknüpfungen umgeht. Diese Optimierungen und ihre Effizienz variieren je nach SQL-Engine, wie zum Beispiel PostgreSQL, MySQL und SQL Server. Wenn du weißt, wie der Optimierer deiner Datenbank funktioniert, kannst du besser Abfragen schreiben, die die Vorteile von Fremdschlüsselbeschränkungen voll nutzen.
Du kannst zum Beispiel die folgende Abfrage verwenden, um den Ausführungsplan in PostgreSQL anzuzeigen:
-- View execution plan
EXPLAIN ANALYZE
SELECT o.order_id, u.email
FROM orders o
JOIN users u ON o.user_id = u.user_id;
Diese Tabelle zeigt, wie du den Ausführungsplan in verschiedenen Datenbanken anschauen kannst:
|
Datenbank |
Befehl |
|
PostgreSQL |
|
|
MySQL |
|
|
SQL Server |
Geschätzter / tatsächlicher Ausführungsplan |
|
Oracle |
|
Ichempfehle dir, unseren Kurs „Joining Data in SQL” zu machen, um die verschiedenen Arten von Verknüpfungen in SQL kennenzulernen und zu lernen, wie man mit verschiedenen verwandten Tabellen in der Datenbank arbeitet.
Fortgeschrittene Anwendungsfälle und bewährte Verfahren
Über die grundlegende Implementierung hinaus kannst du Fremdschlüssel nutzen, um eine robuste, skalierbare und wartungsfreundliche Datenbankarchitektur aufzubauen. In diesem Abschnitt erkläre ich die speziellen Szenarien und die grundlegenden Designprinzipien, die bei der Verwendung von Fremdschlüsseln zu beachten sind.
Datenbank- oder schemübergreifende Beziehungen
Während Fremdschlüssel dafür gedacht sind, die Integrität innerhalb einer einzelnen Datenbank oder eines einzelnen Schemas sicherzustellen, brauchen komplexere Unternehmensumgebungen oft Beziehungen über diese Grenzen hinweg. Die Tabelle unten zeigt, welche Schema- und Datenbankunterstützung es für verschiedene SQL-Dialekte gibt.
|
Datenbank |
Unterstützung für mehrere Schemata |
Unterstützung für mehrere Datenbanken |
Einschränkungen |
|
PostgreSQL |
Ja |
Nein |
Nur für einen einzigen Datenbankcluster. |
|
SQL Server |
Ja |
Ja |
Die Datenbankübergreifende Integrität wird durch Anwendungslogik oder Trigger verwaltet und nicht durch native Fremdschlüssel. |
|
Oracle |
Ja |
Ja |
Datenbankverknüpfungen dienen dem Datenzugriff; native FK-Einschränkungen werden normalerweise nicht über Verknüpfungen hinweg durchgesetzt. |
|
MySQL |
Nein |
Nein |
Nur für Tabellen in derselben Datenbank und mit derselben Speicher-Engine, wie zum Beispiel InnoDB. |
|
SQLite |
Nein |
Nein |
Nur für die bestimmte Datei-/Datenbankverbindung. |
Wartung und Prüfung
Wenn du Fremdschlüssel erstellst, wirst du merken, dass sie sich jedes Mal ändern, wenn sich deine Geschäftslogik ändert. Schau dir mal diese Möglichkeiten an, um die Fremdschlüssel zu überprüfen und zu pflegen, damit sie auf dem neuesten Stand sind:
- Überprüfungsbeschränkungen: Überprüfe regelmäßig Fremdschlüsselbeschränkungen, um sicherzustellen, dass sie mit den sich ändernden Geschäftsregeln und Schemaänderungen übereinstimmen.
- Regelmäßige Indexprüfung: Stell immer sicher, dass Indizes für alle Fremdschlüsselspalten vorhanden sind, um eine optimale Join- und Validierungsleistung zu gewährleisten, vor allem nach großen Datenimporten oder System-Upgrades.
- Dokumentation und Visualisierung: Benutz Entity-Relationship-Diagramme (ER-Diagramme) oder Schema-Visualisierungstools, um Beziehungen zu dokumentieren. Diese visuellen Hilfsmittel sorgen dafür, dass alle Entwickler und Analysten die Beziehungen und Integritätsregeln verstehen, die durch deine Fremdschlüssel durchgesetzt werden.
Bewährte Methoden für ein robustes Datenbankdesign
Um sicherzustellen, dass du die Funktionsweise von Fremdschlüsseln optimal nutzt, halte dich an die folgenden Richtlinien:
-
Richte deine Schlüssel nach echter Geschäftslogik aus: Stell sicher, dass Primär- und Fremdschlüssel echte Entitäten und die Beziehungen zwischen ihnen darstellen, anstatt dich auf künstliche oder instabile Identifikatoren zu verlassen.
-
Benutz klare, einheitliche Namen: Wähle aussagekräftige Namen für Einschränkungen, wie z. B. „
fk_orders_user_id“, damit dein Schema einfacher zu pflegen, zu debuggen und mit anderen zusammen zu bearbeiten ist. -
Strenge und Flexibilität ausbalancieren: Einschränkungen sollten die Datenqualität schützen, aber dein Design sollte trotzdem praktische Sonderfälle oder Validierungen zulassen, die in der Anwendungsschicht abgewickelt werden.
-
Vermeide zirkuläre Beziehungen: Mach dein Schema so, dass Fremdschlüsselabhängigkeiten sich nicht gegenseitig beeinflussen, weil das das Einfügen, Aktualisieren und Löschen unnötig kompliziert macht.
-
Leistung optimieren: Indexiere deine Fremdschlüssel ordentlich und pass auf, dass du kaskadierende Aktionen vorsichtig anwendest, damit die Integrität erhalten bleibt, ohne dass dein System langsamer wird.
Fazit
Wie bei jeder Fertigkeit kommt man auch beim Beherrschen von Fremdschlüsseln nur durch Übung weiter. Probier doch mal Schemamodellierung aus, test Kaskadenaktionen und schau dir an, wie Einschränkungen in echten Szenarien funktionieren. Mit der Zeit wirst du lernen, wie du strenge Regeln mit der Flexibilität, die deine Anwendungen brauchen, in Einklang bringst und so Datenbanken erstellst, die sowohl robust als auch anpassungsfähig sind, wenn sich die Anforderungen ändern.
Jetzt, wo du weißt, wie man Fremdschlüssel beim Datenbankdesign benutzt, empfehle ich dir, unseren Lernpfad „Associate Data Engineer in SQL“ auszuprobieren, um die Grundlagen des Data Engineering und Data Warehousing zu lernen. Wenn du deine Datenbankmanagement-Kenntnisse für Big Data verbessern willst, empfehle ich dir unseren Kurs „Einführung in die Datenmodellierung in Snowflake“, um mehr über dimensionale Modellierung zu erfahren.
FAQs
Was ist der Unterschied zwischen einem Primärschlüssel und einem Fremdschlüssel?
Ein Primärschlüssel macht die Datensätze in seiner eigenen Tabelle eindeutig erkennbar, während ein Fremdschlüssel auf einen Primärschlüssel in einer anderen Tabelle zeigt, um eine Beziehung herzustellen.
Kann eine Tabelle mehrere Fremdschlüssel haben?
Ja, eine Tabelle kann mehrere Fremdschlüssel haben, die jeweils mit verschiedenen übergeordneten Tabellen verbunden sind.
Muss eine Tabelle eindeutige Fremdschlüsselspalten haben?
Nein, Fremdschlüsselspalten können doppelte Werte haben, müssen aber auf gültige Zeilen in der übergeordneten Tabelle zeigen.
Was passiert, wenn du einen Datensatz löschst, auf den ein Fremdschlüssel verweist?
Je nach Einschränkungen kann die Datenbank das Löschen einschränken, zugehörige Zeilen kaskadieren löschen oder Fremdschlüsselwerte auf „ NULL “ setzen.
Sind Fremdschlüssel in relationalen Datenbanken ein Muss?
Obwohl nicht zwingend erforderlich, sind Fremdschlüssel wichtig, um die relationale Integrität und ein zuverlässiges Datenbankdesign sicherzustellen.



