กลับไปที่คู่มือทั้งหมด
การออกแบบฐานข้อมูล··อ่าน 5 นาที

วิธีออกแบบสคีมาฐานข้อมูลตั้งแต่ต้น: คู่มือทีละขั้นตอน

ออกแบบสคีมาฐานข้อมูลเชิงสัมพันธ์ตั้งแต่เริ่มต้น คำแนะนำทีละขั้นตอนตั้งแต่ความต้องการไปจนถึงตาราง ความสัมพันธ์ และข้อจำกัดด้วย SQL

ข้อกำหนดกลายเป็นเอนทิตี, ความสัมพันธ์ และสคีมา SQL พร้อมคีย์ลูกค้าและคำสั่งซื้อ
ในคู่มือนี้
  1. ทำไมการออกแบบสคีมาจึงสำคัญ
  2. ขั้นตอนที่ 1 — รวบรวมความต้องการ
  3. ขั้นตอนที่ 2 — ระบุเอนทิตี
  4. ขั้นตอนที่ 3 — กำหนดแอตทริบิวต์และประเภทข้อมูล
  5. ขั้นตอนที่ 4 — สร้างความสัมพันธ์
  6. ขั้นตอนที่ 5 — ใช้ข้อจำกัดและดัชนี
  7. ขั้นตอนที่ 6 — ทำนอร์มัลไลเซชัน (จากนั้นทำเดนนอร์มัลไลเซชันเมื่อจำเป็น)
  8. ข้อมูลอ้างอิงและการอ่านเพิ่มเติม

ตัวอย่าง SQL จะใช้ PostgreSQL เว้นแต่จะระบุภาษาอื่นไว้ ตัวอย่างสั้นๆ สมมติว่าตารางที่อ้างถึงมีอยู่แล้ว โปรดตรวจสอบความถูกต้องของ DDL ในฐานข้อมูลเป้าหมายของคุณก่อนนำไปใช้งาน

ทำไมการออกแบบสคีมาจึงสำคัญ

สคีมาฐานข้อมูลที่ออกแบบมาอย่างดีคือรากฐานของทุกแอปพลิเคชันที่เชื่อถือได้ หากทำถูกต้อง คิวรีจะรวดเร็ว ข้อมูลจะสอดคล้องกัน และฟีเจอร์ในอนาคตจะถูกเพิ่มเข้ามาโดยไม่ต้องมีการย้ายข้อมูลที่เจ็บปวด หากทำผิด คุณจะต้องต่อสู้กับความผิดปกติของข้อมูล ประสิทธิภาพที่เชื่องช้า และการแก้ไขปัญหาชั่วคราวที่ไม่สิ้นสุดตลอดอายุของโครงการ

คู่มือนี้จะแนะนำผ่าน กระบวนการหกขั้นตอน สำหรับการออกแบบสคีมาตั้งแต่ต้น — และจบลงด้วยตัวอย่างจริงที่สมบูรณ์ที่คุณสามารถนำไปปรับใช้กับโครงการของคุณเองได้

ขั้นตอนที่ 1 — รวบรวมความต้องการ

ก่อนเปิดเครื่องมือใดๆ ให้พูดคุยกับผู้มีส่วนได้ส่วนเสีย ทำความเข้าใจว่าแอปพลิเคชัน ทำ, ข้อมูลที่จัดการ และความสัมพันธ์ของข้อมูลนั้น ถามคำถามเช่น:

  • อะไรคือ "สิ่ง" หลักที่ระบบติดตาม? (ผู้ใช้, คำสั่งซื้อ, ผลิตภัณฑ์ …)
  • ข้อมูลใดที่ต้องไม่ซ้ำกัน? (อีเมล, SKU, สลัก (slugs) …)
  • แอปพลิเคชันจะรันคิวรีใดบ่อยที่สุด?
  • มีข้อจำกัดด้านกฎระเบียบหรือไม่? (GDPR, HIPAA …)
  • ปริมาณข้อมูลที่คาดว่าจะได้รับในช่วง 1–3 ปีข้างหน้าคือเท่าใด?

เขียนคำตอบลงไป — คำตอบเหล่านั้นจะกลายเป็นข้อกำหนดของคุณและจะนำทางทุกการตัดสินใจหลังจากนี้

ขั้นตอนที่ 2 — ระบุเอนทิตี

หนึ่ง เอนทิตี คือสิ่งใดก็ตามที่ระบบจำเป็นต้องจัดเก็บข้อมูลเกี่ยวกับสิ่งนั้น เอนทิตีแต่ละรายการมักจะแมปกับหนึ่งตารางฐานข้อมูล สำหรับแพลตฟอร์มบล็อก รายการเอนทิตีเริ่มต้นอาจมีลักษณะดังนี้:

  • ผู้ใช้ — ผู้เขียนและผู้อ่าน
  • โพสต์ — บทความที่เผยแพร่บนบล็อก
  • หมวดหมู่ — การจัดกลุ่มสำหรับโพสต์ (เช่น "React", "SQL")
  • ความคิดเห็น — การตอบกลับของผู้อ่านต่อโพสต์
  • แท็ก — ป้ายกำกับแบบละเอียด (ความสัมพันธ์แบบกลุ่มต่อกลุ่มกับโพสต์)

ร่างสิ่งเหล่านี้เป็นกล่องบนกระดานไวท์บอร์ดหรือใช้ ตัวสร้าง ERD เพื่อหารือเกี่ยวกับแบบจำลองเชิงแนวคิดก่อนเลือกประเภทคอลัมน์

ขั้นตอนที่ 3 — กำหนดแอตทริบิวต์และประเภทข้อมูล

สำหรับแต่ละเอนทิตี ให้ระบุแอตทริบิวต์ที่จำเป็นและเลือกประเภทข้อมูล SQL ที่เหมาะสมที่สุด ให้มีความเฉพาะเจาะจงมากที่สุดเท่าที่จะเป็นไปได้ — ควรเลือก VARCHAR(255) มากกว่า TEXT เมื่อคุณทราบความยาวสูงสุด และต้องการ TIMESTAMPTZ มากกว่า TIMESTAMP เมื่อเขตเวลา (time zones) มีความสำคัญ

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

ขั้นตอนที่ 4 — สร้างความสัมพันธ์

กำหนดว่าเอนทิตีมีความสัมพันธ์กันอย่างไร ประเภทพื้นฐานสามประการคือ:

  • หนึ่งต่อหลาย (1:N) — ผู้ใช้หนึ่งคนมีหลายโพสต์; โพสต์หนึ่งเป็นของผู้ใช้หนึ่งคน
  • กลุ่มต่อกลุ่ม (M:N) — โพสต์หนึ่งสามารถมีได้หลายแท็ก; แท็กหนึ่งสามารถเป็นของหลายโพสต์ได้ สิ่งนี้ต้องการ ตารางเชื่อม (junction table).
  • หนึ่งต่อหนึ่ง (1:1) — ผู้ใช้หนึ่งคนมีหนึ่งโปรไฟล์ มักจะรวมเป็นตารางเดียวเว้นแต่ข้อมูลโปรไฟล์จะมีขนาดใหญ่หรือเข้าถึงได้ยาก
-- 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)
);

ขั้นตอนที่ 5 — ใช้ข้อจำกัดและดัชนี

ข้อจำกัดช่วยปกป้องคุณภาพของข้อมูล อย่างน้อยที่สุดคุณควรพิจารณา:

  • NOT NULL บนทุกคอลัมน์ที่ต้องมีค่า
  • UNIQUE บนตัวระบุธรรมชาติ (อีเมล, สลัก, ชื่อผู้ใช้)
  • CHECK ข้อจำกัดสำหรับกฎของโดเมน (เช่น สถานะต้องเป็นหนึ่งในสามค่า)
  • DEFAULT ค่าสำหรับคอลัมน์ timestamps และ status
  • Foreign keys พร้อมความชัดเจน ON DELETE การกระทำ

จากนั้นเพิ่ม ดัชนี (indexes) บนคอลัมน์ที่คุณมักจะกรอง เรียงลำดับ หรือเชื่อม (join) บ่อยๆ คอลัมน์ที่เป็นคีย์นอกเป็นตัวเลือกหลัก

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

ขั้นตอนที่ 6 — ทำนอร์มัลไลเซชัน (จากนั้นทำเดนนอร์มัลไลเซชันเมื่อจำเป็น)

การทำให้เป็นบรรทัดฐาน (Normalization) กำจัดข้อมูลที่ซ้ำซ้อนโดยการจัดระเบียบคอลัมน์และตารางตามชุดของ "รูปแบบปกติ" (normal forms) สคีมาส่วนใหญ่ควรไปถึง รูปแบบบรรทัดฐานขั้นที่ 3 (3NF):

  • 1NF — ทุกคอลัมน์เก็บค่าอะตอม; ไม่มีกลุ่มที่ซ้ำกัน
  • 2NF — ไม่มีแอตทริบิวต์ที่ไม่ใช่คีย์หลักที่ขึ้นอยู่กับเพียงบางส่วนของคีย์ผู้สมัคร
  • 3NF — การพึ่งพาที่ไม่ใช่เรื่องเล็กน้อยแต่ละรายการมีตัวกำหนด superkey หรือแอตทริบิวต์ที่ขึ้นต่อกันซึ่งเป็นของคีย์ผู้สมัคร (candidate key)

หลังจากทำ Normalization แล้ว คุณอาจเลือกที่จะ ลดการทำข้อมูลซ้ำ (denormalize) เพื่อประสิทธิภาพ — ตัวอย่างเช่น การจัดเก็บ comment_count บน posts ตารางเพื่อหลีกเลี่ยง COUNT(*) ในการโหลดหน้าเว็บทุกครั้ง ทำ denormalize อย่างตั้งใจและจัดทำเอกสารไว้

สคีมาแพลตฟอร์มบล็อกที่สมบูรณ์

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

วางสคีมาที่สมบูรณ์ลงใน ตัวแก้ไข SQL เป็น ERD เพื่อตรวจสอบความสัมพันธ์ ใช้ ตัวสร้าง ERD สำหรับการวาดภาพเชิงแนวคิดและการแปลง SQL ที่ผ่านการตรวจสอบแล้ว

ข้อมูลอ้างอิงและการอ่านเพิ่มเติม

โพสต์เพิ่มเติม