Terug naar alle handleidingen
Databaseontwerp··5 min leestijd

Een databaseschema vanaf nul ontwerpen: stap voor stap

Ontwerp een relationeel databaseschema vanaf nul. Een stap-voor-stap handleiding van vereisten tot tabellen, relaties en beperkingen met SQL.

Vereisten worden entiteiten, relaties en een SQL-schema met klant- en ordersleutels
In deze gids
  1. Waarom schemadesign belangrijk is
  2. Stap 1 — Verzamel Vereisten
  3. Stap 2 — Identificeer Entiteiten
  4. Stap 3 — Definieer Attributen & Datatypen
  5. Stap 4 — Vestig Relaties
  6. Stap 5 — Pas Beperkingen & Indexen Toe
  7. Stap 6 — Normaliseren (Denormaliseer Dan Waar Nodig)
  8. Referenties en verdere lezing

SQL-voorbeelden gebruiken PostgreSQL, tenzij een andere dialect wordt genoemd. Korte fragmenten gaan ervan uit dat hun verwijderde tabellen al bestaan. Valideer DDL in uw doeldatabase voordat u deze toepast.

Waarom schemadesign belangrijk is

Een goed ontworpen databaseschema is de basis van elke betrouwbare applicatie. Als het goed zit, zijn queries snel, blijven gegevens consistent en kunnen toekomstige functies worden toegevoegd zonder pijnlijke migraties. Als het fout zit, vecht u tegen gegevensanomalieën, trage prestaties en eindeloze work-arounds gedurende de levensduur van het project.

Deze handleiding doorloopt een zesstappenproces voor het ontwerpen van een schema vanaf nul - en eindigt met een volledig praktijkvoorbeeld dat u kunt aanpassen voor uw eigen projecten.

Stap 1 — Verzamel Vereisten

Voordat u enig hulpmiddel opent, spreekt u met belanghebbenden. Begrijp wat de applicatie doet, welke gegevens het beheert en hoe die gegevens zich verhouden. Stel vragen zoals:

  • Wat zijn de belangrijkste "dingen" die het systeem bijhoudt? (Gebruikers, bestellingen, producten...)
  • Welke gegevens moeten uniek zijn? (E-mails, SKU's, slugs …)
  • Welke queries zal de applicatie het vaakst uitvoeren?
  • Zijn er wettelijke beperkingen? (AVG, HIPAA …)
  • Wat is het verwachte datavolume voor de komende 1-3 jaar?

Schrijf de antwoorden op — ze worden uw specificatie en begeleiden elke beslissing die volgt.

Stap 2 — Identificeer Entiteiten

Een entiteit is alles waarover het systeem gegevens moet opslaan. Elke entiteit komt meestal overeen met één databasetabel. Voor een blogplatform kan de initiële entiteitenlijst er als volgt uitzien:

  • Gebruiker — auteurs en lezers
  • Post — artikelen gepubliceerd op de blog
  • Categorie — groeperingen voor berichten (bijv. "React", "SQL")
  • Opmerking — reacties van lezers op berichten
  • Tag — fijnmazige labels (veel-op-veel met berichten)

Schets deze als vakken op een whiteboard of gebruik de ERD-bouwer om het conceptuele model te bespreken voordat kolomtypen worden gekozen.

Stap 3 — Definieer Attributen & Datatypen

Lijst voor elke entiteit de benodigde attributen op en kies het meest geschikte SQL-gegevenstype. Wees zo specifiek mogelijk — geef de voorkeur aan VARCHAR(255) over TEXT wanneer u de maximale lengte kent en de voorkeur geeft aan TIMESTAMPTZ over TIMESTAMP wanneer tijdzones ertoe doen.

-- 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()

Stap 4 — Vestig Relaties

Bepaal hoe entiteiten zich tot elkaar verhouden. De drie fundamentele typen zijn:

  • Eén-op-veel (1:N) — Een gebruiker heeft veel berichten; een bericht behoort tot één gebruiker.
  • Veel-op-veel (M:N) — Een bericht kan veel tags hebben; een tag kan tot veel berichten behoren. Dit vereist een koppeltabel.
  • Eén-op-één (1:1) — Een gebruiker heeft één profiel. Vaak samengevoegd tot één tabel, tenzij de profielgegevens groot zijn of zelden worden geraadpleegd.
-- 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)
);

Stap 5 — Pas Beperkingen & Indexen Toe

Beperkingen beschermen de datakwaliteit. U dient minimaal te overwegen:

  • NOT NULL op elke kolom die een waarde moet hebben.
  • UNIQUE op natuurlijke identificatoren (e-mails, slugs, gebruikersnamen).
  • CHECK constraints voor domeinregels (bijv. status moet een van de drie waarden zijn).
  • DEFAULT waarden voor tijdstempel- en statuskolommen.
  • Vreemde sleutels met expliciete ON DELETE acties.

Voeg dan toe indexen op kolommen waarop u vaak filtert, sorteert of koppelt. Vreemde-sleutelkolommen zijn hiervoor uitstekende 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';

Stap 6 — Normaliseren (Denormaliseer Dan Waar Nodig)

Normalisatie elimineert redundante gegevens door kolommen en tabellen te organiseren volgens een set "normale vormen". De meeste schema's zouden moeten bereiken Derde Normale Vorm (3NF):

  • 1NF — elke kolom bevat atomische waarden; geen herhalende groepen.
  • 2NF — geen niet-priem attribuut hangt af van slechts een deel van een kandidaatsleutel.
  • 3NF — elke niet-triviale afhankelijkheid heeft een superkey determinant of een afhankelijk attribuut dat behoort tot een kandidaatsleutel.

Na normalisatie kunt u selectief denormaliseren voor prestaties - bijvoorbeeld, het opslaan van een comment_count op de posts tabel om een kostbare COUNT(*) bij elke paginalading. Denormaliseer bewust en documenteer het.

Volledig blogplatformschema

-- 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);

Plak het volledige schema in de SQL-naar-ERD-editor om de relaties te inspecteren. Gebruik de ERD-bouwer voor een conceptuele tekening en een beoordeelde SQL-conversie.

Referenties en verdere lezing

Meer berichten