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

หนึ่งต่อหลายกับหลายต่อหลาย: รูปแบบความสัมพันธ์ SQL

เรียนรู้ความสัมพันธ์แบบหนึ่งต่อกลุ่ม (one-to-many) เทียบกับกลุ่มต่อกลุ่ม (many-to-many) ใน SQL ดูวิธีการนำไปใช้งานจริงด้วยคีย์นอก (foreign keys), ตารางเชื่อม (junction tables) และตัวอย่างจากสถานการณ์จริง

คีย์นอกจากลูกค้าไปยังคำสั่งซื้อ และตารางเชื่อมระหว่างนักเรียนกับหลักสูตรพร้อมคีย์หลักแบบผสม
ในคู่มือนี้
  1. ทำความเข้าใจรูปแบบความสัมพันธ์ของ SQL
  2. ความสัมพันธ์แบบหนึ่งต่อหลาย
  3. ความสัมพันธ์แบบกลุ่มต่อกลุ่ม
  4. ความสัมพันธ์แบบหนึ่งต่อหนึ่ง
  5. ความสัมพันธ์ปรากฏใน ERD อย่างไร
  6. การเลือกรูปแบบความสัมพันธ์ที่ถูกต้อง
  7. ข้อมูลอ้างอิงและการอ่านเพิ่มเติม

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

ทำความเข้าใจรูปแบบความสัมพันธ์ของ SQL

ฐานข้อมูลเชิงสัมพันธ์ได้รับพลังมาจากความเชื่อมโยงระหว่างตาราง ไม่ว่าคุณจะออกแบบแอปพลิเคชันขนาดเล็กหรือคลังข้อมูลระดับองค์กร การเลือกรูปแบบความสัมพันธ์ที่ถูกต้องจะเป็นตัวกำหนดว่าคุณสามารถจัดเก็บ คิวรี และดูแลรักษาข้อมูลของคุณได้อย่างมีประสิทธิภาพเพียงใด รูปแบบพื้นฐานทั้งสามคือ—one-to-one, one-to-many, และ many-to-many—ครอบคลุมความสัมพันธ์ทั่วไปหลายอย่าง; ความสัมพันธ์แบบเรียกซ้ำและระดับสูงต้องการการสร้างแบบจำลองเพิ่มเติม

ในคู่มือนี้ เราจะแจกแจงแต่ละรูปแบบด้วยตัวอย่าง PostgreSQL สำรวจบทบาทของตารางเชื่อม (junction tables) และแสดงให้เห็นว่าความสัมพันธ์เหล่านี้ปรากฏบนแผนภาพ ERD อย่างไร หากคุณต้องการเห็นภาพสคีมาของคุณเองในขณะนี้ ให้เปิด ตัวแก้ไข Erd Go และวางสิ่งที่รองรับ CREATE TABLE คำนิยามเพื่อสร้างแผนภาพ

Foreign key SQL ที่แมปกับความสัมพันธ์ ERD ระหว่างลูกค้าและคำสั่งซื้อ
คีย์นอกเป็นมากกว่าแค่ไวยากรณ์ ใน ERD มันจะกลายเป็นเส้นความสัมพันธ์ที่อธิบายว่าตารางต่างๆ ขึ้นต่อกันอย่างไร

ความสัมพันธ์แบบหนึ่งต่อหลาย

A one-to-many ความสัมพันธ์ (1:N) เป็นรูปแบบที่พบบ่อยที่สุดในการออกแบบฐานข้อมูล หมายความว่าแถวเดียวใน แม่ (parent) ตารางสามารถถูกอ้างอิงโดยหลายแถวใน ลูก ตาราง และคีย์นอกของลูกที่ไม่เป็นค่าว่างจะชี้ไปยังพาเรนต์หนึ่งตัว คีย์นอกที่สามารถเป็นค่าว่างได้จะอนุญาตให้มีลูกที่ไม่มีพาเรนต์

ตัวอย่างคลาสสิก: แผนกและพนักงาน

บริษัทหนึ่งมีหลายแผนก และแต่ละแผนกประกอบด้วยพนักงานหลายคน อย่างไรก็ตาม พนักงานทุกคนสังกัดอยู่เพียงแผนกเดียวเท่านั้น ณ เวลาใดเวลาหนึ่ง

CREATE TABLE departments (
    id          SERIAL PRIMARY KEY,
    name        VARCHAR(100) NOT NULL,
    location    VARCHAR(255),
    created_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE employees (
    id              SERIAL PRIMARY KEY,
    first_name      VARCHAR(50) NOT NULL,
    last_name       VARCHAR(50) NOT NULL,
    email           VARCHAR(255) UNIQUE NOT NULL,
    department_id   INT NOT NULL,
    hire_date       DATE DEFAULT CURRENT_DATE,
    CONSTRAINT fk_department
        FOREIGN KEY (department_id)
        REFERENCES departments (id)
        ON DELETE RESTRICT
        ON UPDATE CASCADE
);

รายละเอียดสำคัญในการนำไปใช้งาน

  • คีย์นอก (department_id) จะอยู่บน many ด้าน— employees ตารางในกรณีนี้
  • ON DELETE RESTRICT ป้องกันการลบแผนกที่มีพนักงานประจำอยู่โดยไม่ได้ตั้งใจ
  • ON UPDATE CASCADE รับประกันว่าหากคีย์หลักของแผนกเปลี่ยนไป แถวของพนักงานทั้งหมดจะอัปเดตโดยอัตโนมัติ
  • การเพิ่มดัชนีบน department_id สามารถช่วยในการจอยน์และตัวกรองแผนก ยืนยันประโยชน์ด้วยข้อมูลที่เป็นตัวแทนและแผนการทำงาน (execution plan)

การคิวรีข้อมูลแบบ One-to-Many

-- All employees in the Engineering department
SELECT e.first_name, e.last_name, d.name AS department
FROM employees e
JOIN departments d ON d.id = e.department_id
WHERE d.name = 'Engineering';

-- Count employees per department
SELECT d.name, COUNT(e.id) AS headcount
FROM departments d
LEFT JOIN employees e ON e.department_id = d.id
GROUP BY d.id, d.name
ORDER BY headcount DESC;

ตัวอย่างความสัมพันธ์แบบหนึ่งต่อกลุ่มอื่นๆ ในชีวิตประจำวัน ได้แก่ ผู้เขียน → โพสต์บล็อก, ลูกค้า → คำสั่งซื้อ, และ หมวดหมู่ → สินค้า.

ความสัมพันธ์แบบกลุ่มต่อกลุ่ม

A many-to-many ความสัมพันธ์ (M:N) จะเกิดขึ้นเมื่อแถวบน ทั้งคู่ แต่ละด้านสามารถเชื่อมโยงกับหลายแถวในอีกด้านหนึ่งได้ ฐานข้อมูลเชิงสัมพันธ์ไม่สามารถแสดงสิ่งนี้โดยตรงด้วยคีย์นอกเพียงคีย์เดียว ดังนั้นเราจึงแนะนำ ตารางเชื่อม (junction table) (เรียกอีกอย่างว่า สะพาน, join, หรือ แบบเชื่อมโยง (associative) ตาราง)

ตัวอย่างคลาสสิก: นักเรียนและหลักสูตร

นักเรียนหนึ่งคนสามารถลงทะเบียนได้หลายหลักสูตร และแต่ละหลักสูตรสามารถมีนักเรียนได้หลายคน ตารางเชื่อมต่อ enrollments อยู่ระหว่างทั้งสองและเก็บคีย์นอกไว้ทั้งสองด้าน

CREATE TABLE students (
    id          SERIAL PRIMARY KEY,
    full_name   VARCHAR(120) NOT NULL,
    email       VARCHAR(255) UNIQUE NOT NULL,
    enrolled_on DATE DEFAULT CURRENT_DATE
);

CREATE TABLE courses (
    id          SERIAL PRIMARY KEY,
    title       VARCHAR(200) NOT NULL,
    credits     SMALLINT NOT NULL DEFAULT 3,
    department  VARCHAR(100)
);

CREATE TABLE enrollments (
    student_id  INT NOT NULL REFERENCES students (id) ON DELETE CASCADE,
    course_id   INT NOT NULL REFERENCES courses (id) ON DELETE CASCADE,
    enrolled_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    grade       CHAR(2),
    PRIMARY KEY (student_id, course_id)
);

ทำไมต้องมีตารางเชื่อม (Junction Table)?

  • เดอะ คีย์หลักแบบผสม (student_id, course_id) อนุญาตให้มีหนึ่งแถวต่อคู่ของนักเรียนและหลักสูตร หากจำเป็นต้องมีการลงทะเบียนซ้ำในแต่ละภาคการศึกษา ให้รวมภาคการศึกษาไว้ในคีย์ธุรกิจหรือสร้างแบบจำลองการลงทะเบียนแต่ละรายการแยกกัน
  • คุณสามารถแนบแอตทริบิวต์เพิ่มเติมให้กับความสัมพันธ์นั้นได้ เช่น grade หรือ enrolled_at, ซึ่งไม่ได้เป็นของเอนทิตีใดเอนทิตีหนึ่งเพียงอย่างเดียว
  • ON DELETE CASCADE บนคีย์นอก (foreign keys) ทั้งสองตัวหมายความว่าการลบนักเรียนหรือหลักสูตรจะล้างแถวการลงทะเบียนโดยอัตโนมัติ

การคิวรีข้อมูลแบบ Many-to-Many

-- All courses for a specific student
SELECT c.title, c.credits, e.grade
FROM enrollments e
JOIN courses c ON c.id = e.course_id
WHERE e.student_id = 42;

-- Students enrolled in 'Database Systems'
SELECT s.full_name, s.email
FROM enrollments e
JOIN students s ON s.id = e.student_id
JOIN courses c ON c.id = e.course_id
WHERE c.title = 'Database Systems';

ตัวอย่าง Many-to-Many ในโลกแห่งความเป็นจริง ได้แก่ ผู้ใช้ ↔ บทบาท, สินค้า ↔ แท็ก, นักแสดง ↔ ภาพยนตร์, และ คำสั่งซื้อ ↔ สินค้า (ผ่านทาง order_items ตารางเชื่อมที่เก็บข้อมูลปริมาณและราคาด้วย)

ความสัมพันธ์แบบหนึ่งต่อหนึ่ง

A one-to-one ความสัมพันธ์ (1:1) หมายความว่าแต่ละแถวในตาราง A จะจับคู่กับแถวในตาราง B ได้สูงสุดหนึ่งแถว และในทางกลับกัน รูปแบบนี้พบได้น้อยกว่าแต่มีประโยชน์สำหรับการแยกคอลัมน์ที่เข้าถึงได้ยากหรือข้อมูลที่ละเอียดอ่อนออกไปไว้ในตารางแยกต่างหาก

CREATE TABLE users (
    id          SERIAL PRIMARY KEY,
    username    VARCHAR(60) UNIQUE NOT NULL,
    email       VARCHAR(255) UNIQUE NOT NULL
);

CREATE TABLE user_profiles (
    user_id     INT PRIMARY KEY REFERENCES users (id) ON DELETE CASCADE,
    bio         TEXT,
    avatar_url  VARCHAR(500),
    birthdate   DATE,
    updated_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

สังเกตว่า user_profiles.user_id เป็นทั้ง คีย์หลัก (primary key) และ คีย์นอก. ข้อจำกัดนี้บังคับใช้การแมปแบบหนึ่งต่อหนึ่งที่ระดับฐานข้อมูล—ผู้ใช้แต่ละคนสามารถมีแถวโปรไฟล์ได้สูงสุดหนึ่งแถว

ความสัมพันธ์ปรากฏใน ERD อย่างไร

แผนภาพความสัมพันธ์ระหว่างเอนทิตี (ERD) ใช้เส้นและสัญลักษณ์ระหว่างตารางเพื่อสื่อถึงความเป็นสมาชิก (cardinality) ได้อย่างรวดเร็ว สัญกรณ์ที่ได้รับความนิยมมากที่สุดสองแบบคือ Crow’s Foot และ Chen สัญกรณ์

ความสัมพันธ์สัญลักษณ์ Crow’s Footวิธีการอ่าน
หนึ่งต่อหนึ่ง||—||อย่างละหนึ่งรายการในแต่ละด้าน
หนึ่งต่อหลาย||—<หนึ่งทางซ้าย หลายทางขวา (ปลายเท้าอีกา)
กลุ่มต่อกลุ่ม>—<ความสัมพันธ์แบบกลุ่มต่อกลุ่มทั้งสองฝั่ง; ดำเนินการผ่านตารางเชื่อม

สัญลักษณ์ข้อความเหล่านี้เป็นตัวย่อสำหรับค่าสูงสุดของความสัมพันธ์ (maximum cardinality) ส่วนความเป็นทางเลือก (optionality) จำเป็นต้องมีตัวบ่งชี้ศูนย์หรือหนึ่งเพิ่มเติม คีย์นอกเพียงอย่างเดียวไม่จำเป็นต้องกำหนดให้พาเรนต์ต้องมีลูก

เมื่อคุณสร้างแบบจำลองความสัมพันธ์แบบกลุ่มต่อกลุ่ม (many-to-many) ในเครื่องมือ ERD คุณมักจะเห็นกล่องสามกล่อง ได้แก่ ตารางเอนทิตีสองตารางและตารางเชื่อมต่อระหว่างกัน โดยแต่ละตารางเชื่อมต่อด้วยเส้นแบบหนึ่งต่อกลุ่ม

วางตัวอย่าง SQL ใดๆ จากบทความนี้ลงใน ตัวแก้ไข Erd Go เพื่อดูแผนภาพที่สร้างขึ้นโดยอัตโนมัติ พร้อมด้วยลูกศรคีย์นอกและตัวบ่งชี้ความเป็นสมาชิก

การเลือกรูปแบบความสัมพันธ์ที่ถูกต้อง

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

  • แถวหนึ่งในฝั่ง A สามารถสัมพันธ์กับหลายแถวในฝั่ง B ได้หรือไม่ แต่ไม่ใช่ในทางกลับกัน? → หนึ่งต่อกลุ่ม (One-to-Many) วางคีย์นอกไว้ที่ฝั่ง B
  • แถวทั้งสองฝั่งสามารถสัมพันธ์กับหลายแถวในอีกฝั่งได้หรือไม่? → กลุ่มต่อกลุ่ม (Many-to-Many) สร้างตารางเชื่อมต่อที่มีคีย์ผสม
  • การแมปเป็น 1:1 อย่างเคร่งครัดและคุณจำเป็นต้องแยกตารางหรือไม่? → หนึ่งต่อหนึ่ง (One-to-One) ใช้คีย์หลักเดียวกันเป็นคีย์นอก

หากไม่แน่ใจ ให้ร่างสคีมาของคุณก่อน ERD แบบรวดเร็วจะเผยให้เห็นปัญหาความสัมพันธ์ได้เร็วกว่าการไปพบข้อผิดพลาดของข้อจำกัด (constraint errors) ในการใช้งานจริง ลองสร้างแผนภาพของคุณใน ตัวแก้ไข Erd Go—ใช้เวลาเพียงไม่กี่วินาทีและสามารถประหยัดเวลาในการดีบั๊กได้หลายชั่วโมง

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

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