Zurück zu allen Anleitungen
Datenbankentwurf··5 Min. Lesezeit

Ein Datenbankschema von Grund auf entwerfen: Schritt für Schritt

Entwerfen Sie ein relationales Datenbankschema von Grund auf. Eine Schritt-für-Schritt-Anleitung von den Anforderungen bis zu Tabellen, Beziehungen und Integritätsbedingungen mit SQL.

Anforderungen werden zu Entitäten, Beziehungen und einem SQL-Schema mit Kunden- und Bestellschlüsseln
In diesem Leitfaden
  1. Warum Schemadesign wichtig ist
  2. Schritt 1 — Anforderungen sammeln
  3. Schritt 2 — Entitäten identifizieren
  4. Schritt 3 — Attribute & Datentypen definieren
  5. Schritt 4 — Beziehungen herstellen
  6. Schritt 5 — Constraints & Indizes anwenden
  7. Schritt 6 — Normalisieren (dann bei Bedarf denormalisieren)
  8. Referenzen und weiterführende Literatur

SQL-Beispiele verwenden PostgreSQL, sofern kein anderes Dialekt genannt wird. Kurze Schnipsel setzen voraus, dass ihre referenzierten Tabellen bereits existieren. Validieren Sie DDL in Ihrer Zieldatenbank, bevor Sie sie anwenden.

Warum Schemadesign wichtig ist

Ein gut entworfenes Datenbankschema ist das Fundament jeder zuverlässigen Anwendung. Wenn es stimmt, sind Abfragen schnell, die Daten bleiben konsistent und zukünftige Funktionen lassen sich ohne schmerzhafte Migrationen einfügen. Wenn es falsch ist, kämpfen Sie während der gesamten Projektlaufzeit mit Datenanomalien, träger Leistung und endlosen Workarounds.

Dieser Leitfaden führt durch ein sechsschrittiger Prozess für den Entwurf eines Schemas von Grund auf — und endet mit einem vollständigen, realen Beispiel, das Sie für Ihre eigenen Projekte anpassen können.

Schritt 1 — Anforderungen sammeln

Sprechen Sie mit Stakeholdern, bevor Sie ein Tool öffnen. Verstehen Sie, was die Anwendung führt aus, welche Daten sie verwaltet und wie diese Daten zusammenhängen. Stellen Sie Fragen wie:

  • Was sind die wichtigsten „Dinge“, die das System verfolgt? (Benutzer, Bestellungen, Produkte …)
  • Welche Daten müssen eindeutig sein? (E-Mails, SKUs, Slugs …)
  • Welche Abfragen wird die Anwendung am häufigsten ausführen?
  • Gibt es regulatorische Einschränkungen? (DSGVO, HIPAA …)
  • Wie hoch ist das erwartete Datenvolumen in den nächsten 1–3 Jahren?

Schreiben Sie die Antworten auf — sie werden zu Ihrer Spezifikation und leiten jede folgende Entscheidung.

Schritt 2 — Entitäten identifizieren

Ein Entität ist alles, worüber das System Daten speichern muss. Jede Entität entspricht typischerweise einer Datenbanktabelle. Für eine Blog-Plattform könnte die initiale Entitätsliste wie folgt aussehen:

  • Benutzer — Autoren und Leser
  • Post — im Blog veröffentlichte Artikel
  • Kategorie — Gruppierungen für Beiträge (z. B. „React“, „SQL“)
  • Kommentar — Leserantworten auf Beiträge
  • Tag — feingranulare Labels (viele-zu-viele mit Beiträgen)

Skizzieren Sie diese als Kästchen auf einem Whiteboard oder verwenden Sie das ERD-Builder um das konzeptionelle Modell zu besprechen, bevor Spaltentypen ausgewählt werden.

Schritt 3 — Attribute & Datentypen definieren

Listen Sie für jede Entität die benötigten Attribute auf und wählen Sie den geeignetsten SQL-Datentyp. Seien Sie so spezifisch wie möglich — bevorzugen Sie VARCHAR(255) über TEXT wenn Sie die maximale Länge kennen und bevorzugen TIMESTAMPTZ über TIMESTAMP wenn Zeitzonen wichtig sind.

-- Users
id          SERIAL PRIMARY KEY
username    VARCHAR(50)  NOT NULL UNIQUE
email       VARCHAR(255) NOT NULL UNIQUE
password_hash TEXT      NOT NULL          -- store a password hash, never plaintext
bio         TEXT
avatar_url  VARCHAR(500)
created_at  TIMESTAMPTZ  DEFAULT now()

-- Posts
id          SERIAL PRIMARY KEY
author_id   INT          NOT NULL          -- FK → users.id
category_id INT                            -- FK → categories.id
title       VARCHAR(200) NOT NULL
slug        VARCHAR(220) NOT NULL UNIQUE
body        TEXT         NOT NULL
status      VARCHAR(20)  DEFAULT 'draft'   -- draft | published | archived
published_at TIMESTAMPTZ
created_at  TIMESTAMPTZ  DEFAULT now()
updated_at  TIMESTAMPTZ  DEFAULT now()

Schritt 4 — Beziehungen herstellen

Bestimmen Sie, wie Entitäten zueinander in Beziehung stehen. Die drei grundlegenden Typen sind:

  • Eins zu vielen (1:N) — Ein Benutzer hat viele Beiträge; ein Beitrag gehört zu einem Benutzer.
  • Viele-zu-Viele (M:N) — Ein Beitrag kann viele Tags haben; ein Tag kann zu vielen Beiträgen gehören. Dies erfordert eine/n Verknüpfungstabelle.
  • Eins-zu-Eins (1:1) — Ein Benutzer hat ein Profil. Wird oft in einer einzigen Tabelle zusammengefasst, es sei denn, die Profildaten sind groß oder werden selten abgerufen.
-- Junction table for the posts ↔ tags many-to-many relationship
CREATE TABLE post_tags (
    post_id INT NOT NULL REFERENCES posts (id) ON DELETE CASCADE,
    tag_id  INT NOT NULL REFERENCES tags  (id) ON DELETE CASCADE,
    PRIMARY KEY (post_id, tag_id)
);

Schritt 5 — Constraints & Indizes anwenden

Einschränkungen schützen die Datenqualität. Mindestens sollten Sie Folgendes berücksichtigen:

  • NOT NULL für jede Spalte, die einen Wert haben muss.
  • UNIQUE auf natürlichen Identifizierern (E-Mails, Slugs, Benutzernamen).
  • CHECK Bedingungen für Domänenregeln (z. B. Status muss einer von drei Werten sein).
  • DEFAULT Werte für Zeitstempel- und Statusspalten.
  • Fremdschlüssel mit explizitem ON DELETE Aktionen.

Dann hinzufügen Indizes auf Spalten, nach denen Sie häufig filtern, sortieren oder JOINs ausführen. Fremdschlüsselspalten sind hervorragende Kandidaten.

-- Index foreign-key columns for faster joins
CREATE INDEX idx_posts_author   ON posts (author_id);
CREATE INDEX idx_posts_category ON posts (category_id);
CREATE INDEX idx_comments_post  ON comments (post_id);

-- Partial index: only published posts (PostgreSQL)
CREATE INDEX idx_posts_published
    ON posts (published_at DESC)
    WHERE status = 'published';

Schritt 6 — Normalisieren (dann bei Bedarf denormalisieren)

Normalisierung eliminiert redundante Daten durch Organisation von Spalten und Tabellen gemäß einer Reihe von „Normalformen“. Die meisten Schemata sollten erreichen Dritte Normalform (3NF):

  • 1NF — Jede Spalte enthält atomare Werte; keine sich wiederholenden Gruppen.
  • 2NF — kein nicht-primäres Attribut hängt nur von einem Teil eines Kandidatenschlüssels ab.
  • 3NF — Jede nicht-triviale Abhängigkeit hat einen Superkey-Determinanten oder ein abhängiges Attribut, das zu einem Kandidatenschlüssel gehört.

Nach der Normalisierung können Sie selektiv denormalisieren für die Leistung — zum Beispiel das Speichern eines comment_count auf dem/der posts Tabelle, um eine kostspielige COUNT(*) bei jedem Laden der Seite. Denormalisieren Sie bewusst und dokumentieren Sie es.

Vollständiges Blog-Plattform-Schema

-- Full SQL for the blog platform schema

CREATE TABLE users (
    id          SERIAL       PRIMARY KEY,
    username    VARCHAR(50)  NOT NULL UNIQUE,
    email       VARCHAR(255) NOT NULL UNIQUE,
    password_hash TEXT      NOT NULL,
    bio         TEXT,
    avatar_url  VARCHAR(500),
    created_at  TIMESTAMPTZ  DEFAULT now()
);

CREATE TABLE categories (
    id   SERIAL       PRIMARY KEY,
    name VARCHAR(100) NOT NULL UNIQUE,
    slug VARCHAR(110) NOT NULL UNIQUE
);

CREATE TABLE posts (
    id           SERIAL       PRIMARY KEY,
    author_id    INT          NOT NULL REFERENCES users (id),
    category_id  INT          REFERENCES categories (id) ON DELETE SET NULL,
    title        VARCHAR(200) NOT NULL,
    slug         VARCHAR(220) NOT NULL UNIQUE,
    body         TEXT         NOT NULL,
    status       VARCHAR(20)  NOT NULL DEFAULT 'draft'
                     CHECK (status IN ('draft','published','archived')),
    published_at TIMESTAMPTZ,
    created_at   TIMESTAMPTZ  DEFAULT now(),
    updated_at   TIMESTAMPTZ  DEFAULT now()
);

CREATE TABLE tags (
    id   SERIAL       PRIMARY KEY,
    name VARCHAR(60)  NOT NULL UNIQUE
);

CREATE TABLE post_tags (
    post_id INT NOT NULL REFERENCES posts (id) ON DELETE CASCADE,
    tag_id  INT NOT NULL REFERENCES tags  (id) ON DELETE CASCADE,
    PRIMARY KEY (post_id, tag_id)
);

CREATE TABLE comments (
    id         SERIAL      PRIMARY KEY,
    post_id    INT         NOT NULL REFERENCES posts (id) ON DELETE CASCADE,
    user_id    INT         NOT NULL REFERENCES users (id),
    body       TEXT        NOT NULL,
    created_at TIMESTAMPTZ DEFAULT now()
);

-- Indexes
CREATE INDEX idx_posts_author    ON posts    (author_id);
CREATE INDEX idx_posts_category  ON posts    (category_id);
CREATE INDEX idx_comments_post   ON comments (post_id);
CREATE INDEX idx_comments_user   ON comments (user_id);

Fügen Sie das vollständige Schema in den SQL-zu-ERD-Editor um seine Beziehungen zu überprüfen. Verwenden Sie den ERD-Builder für eine konzeptionelle Zeichnung und eine überprüfte SQL-Konvertierung.

Referenzen und weiterführende Literatur

Weitere Beiträge