Powrót do wszystkich przewodników
Projektowanie baz danych··5 min czytania

Jak zaprojektować schemat bazy danych od zera: krok po kroku

Zaprojektuj relacyjny schemat bazy danych od zera. Przewodnik krok po kroku od wymagań do tabel, relacji i ograniczeń za pomocą SQL.

Wymagania stają się encjami, relacjami i schematem SQL z kluczami klienta i zamówienia
W tym przewodniku
  1. Dlaczego projektowanie schematu ma znaczenie
  2. Krok 1 — Zbierz wymagania
  3. Krok 2 — Zidentyfikuj encje
  4. Krok 3 — Zdefiniuj atrybuty i typy danych
  5. Krok 4 — Ustanów relacje
  6. Krok 5 — Zastosuj ograniczenia i indeksy
  7. Krok 6 — Normalizuj (następnie denormalizuj tam, gdzie to konieczne)
  8. Referencje i dalsza lektura

Przykłady SQL używają PostgreSQL, chyba że wymieniono inny dialekt. Krótkie fragmenty zakładają, że tabele, do których się odwołują, już istnieją. Zweryfikuj DDL w docelowej bazie danych przed jego zastosowaniem.

Dlaczego projektowanie schematu ma znaczenie

Dobrze zaprojektowany schemat bazy danych jest fundamentem każdej niezawodnej aplikacji. Zrób to dobrze, a Zapytania będą szybkie, Dane pozostaną spójne, a przyszłe funkcje zostaną wprowadzone bez bolesnych migracji. Zrób to źle, a będziesz walczyć z anomaliami danych, powolną wydajnością i niekończącymi się obejściami przez cały okres trwania projektu.

Ten przewodnik prowadzi przez sześcioetapowy proces do projektowania schematu od zera — i kończy się pełnym przykładem ze świata rzeczywistego, który możesz dostosować do własnych projektów.

Krok 1 — Zbierz wymagania

Przed otwarciem jakiegokolwiek narzędzia porozmawiaj z interesariuszami. Zrozum, co aplikacja wykonuje, jakimi Danymi zarządza i jak te Dane są ze sobą powiązane. Zadawaj pytania takie jak:

  • Jakie są główne „rzeczy”, które śledzi system? (Użytkownicy, zamówienia, produkty…)
  • Które dane muszą być unikalne? (E-maile, SKU, slugi …)
  • Jakie zapytania aplikacja będzie uruchamiać najczęściej?
  • Czy istnieją ograniczenia regulacyjne? (RODO, HIPAA …)
  • Jaki jest przewidywany wolumen danych w ciągu najbliższych 1–3 lat?

Zapisz odpowiedzi — staną się one Twoją specyfikacją i będą kierować każdą kolejną decyzją.

Krok 2 — Zidentyfikuj encje

Jeden encja to wszystko, o czym system musi przechowywać dane. Każda encja zazwyczaj mapuje się na jedną tabelę bazy danych. W przypadku platformy blogowej początkowa lista encji może wyglądać następująco:

  • Użytkownik — autorzy i czytelnicy
  • Post — artykuły opublikowane na blogu
  • Kategoria — grupowanie postów (np. "React", "SQL")
  • Komentarz — odpowiedzi czytelników na posty
  • Tag — szczegółowe etykiety (wiele do wielu z postami)

Naszkicuj je jako prostokąty na tablicy lub użyj Kreator ERD aby omówić model koncepcyjny przed wyborem typów kolumn.

Krok 3 — Zdefiniuj atrybuty i typy danych

Dla każdej encji wypisz potrzebne jej atrybuty i wybierz najbardziej odpowiedni typ danych SQL. Bądź tak konkretny, jak to możliwe — preferuj VARCHAR(255) nad TEXT gdy znasz maksymalną długość i preferujesz TIMESTAMPTZ nad TIMESTAMP gdy strefy czasowe mają znaczenie.

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

Krok 4 — Ustanów relacje

Określ, jak encje odnoszą się do siebie. Trzy podstawowe typy to:

  • Jeden do wielu (1:N) — Użytkownik ma wiele postów; post należy do jednego użytkownika.
  • Wiele do wielu (M:N) — Post może mieć wiele tagów; tag może należeć do wielu postów. Wymaga to tabela łącząca.
  • Jeden do jednego (1:1) — Użytkownik ma jeden profil. Często łączone w jedną tabelę, chyba że dane profilu są duże lub rzadko używane.
-- 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)
);

Krok 5 — Zastosuj ograniczenia i indeksy

Ograniczenia chronią jakość Dane. Powinieneś rozważyć co najmniej:

  • NOT NULL na każdej kolumnie, która musi mieć wartość.
  • UNIQUE na naturalnych identyfikatorach (e-maile, slugi, nazwy użytkowników).
  • CHECK ograniczenia dla reguł domenowych (np. status musi być jedną z trzech wartości).
  • DEFAULT wartości dla kolumn znaczników czasu i statusu.
  • Klucze obce z jawnym ON DELETE akcje.

Następnie dodaj indeksy na kolumnach, po których będziesz często filtrować, sortować lub łączyć. Kolumny kluczy obcych są głównymi kandydatami.

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

Krok 6 — Normalizuj (następnie denormalizuj tam, gdzie to konieczne)

Normalizacja eliminuje nadmiarowe Dane poprzez organizowanie kolumn i tabel zgodnie z zestawem „form normalnych”. Większość schematów powinna osiągnąć Trzecia postać normalna (3NF):

  • 1NF — każda kolumna zawiera wartości atomowe; brak powtarzających się grup.
  • 2NF — żaden atrybut niekluczowy nie zależy od tylko części klucza kandydującego.
  • 3NF — każda nietrywialna zależność ma determinant będący superkluczem lub atrybut zależny należący do klucza kandydującego.

Po normalizacji możesz selektywnie denormalizować dla wydajności — na przykład przechowywanie comment_count na posts tabela, aby uniknąć kosztownego COUNT(*) przy każdym ładowaniu strony. Denormalizuj celowo i dokumentuj to.

Kompletny schemat platformy blogowej

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

Wklej kompletny schemat do Edytor SQL do ERD aby sprawdzić jego relacje. Użyj Kreator ERD dla rysunku koncepcyjnego i zweryfikowanej konwersji SQL.

Referencje i dalsza lektura

Więcej postów