คุณสร้างโมเดลความสัมพันธ์ (relationships) ใน ORM อย่างไร?

Question

Accepted Answer

ORM ของ Django สร้างโมเดลความสัมพันธ์พื้นฐานสามแบบของ database ด้วย field type เฉพาะ: **ForeignKey** (one-to-many), **ManyToManyField** (many-to-many) และ **OneToOneField** (one-to-one) สิ่งเหล่านี้นิยามว่า table สัมพันธ์กันอย่างไรและให้คุณเข้าถึง object ที่เกี่ยวข้องในแบบ Python

## ForeignKey — one-to-many (พบบ่อยที่สุด)

```python
class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(
        Author,
        on_delete=models.CASCADE,        # what happens if the author is deleted
        related_name="books",            # access the reverse: author.books
    )
```

```python
# access related objects naturally:
book.author                # the Author this book belongs to (forward)
author.books.all()         # all Books by this author (reverse, via related_name)
```

`ForeignKey` สร้างโมเดล "หนังสือหลายเล่มเป็นของผู้เขียนคนเดียว" พฤติกรรม `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL` ฯลฯ) เป็นสิ่งที่**จำเป็นต้องระบุ**และนิยามว่าจะเกิดอะไรขึ้นกับหนังสือหากผู้เขียนถูกลบ

## ManyToManyField — many-to-many

```python
class Article(models.Model):
    title = models.CharField(max_length=200)
    tags = models.ManyToManyField("Tag", related_name="articles")   # many tags ↔ many articles

class Tag(models.Model):
    name = models.CharField(max_length=50)
```

```python
article.tags.add(tag1, tag2)        # associate tags
article.tags.all()                   # all tags on this article
tag.articles.all()                   # all articles with this tag (reverse)
```

Django สร้าง **join table** เบื้องหลัง `ManyToManyField` โดยอัตโนมัติ — คุณแค่ใช้ `.add()`, `.remove()`, `.all()` (สำหรับข้อมูลเพิ่มเติมบนความสัมพันธ์ ให้ใช้ `through` model)

## OneToOneField — one-to-one

```python
class User(models.Model):
    username = models.CharField(max_length=50)

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)   # one profile per user
    bio = models.TextField()
```

`OneToOneField` บังคับใช้การเชื่อมโยงแบบ one-to-one อย่างเข้มงวด — มักใช้ขยาย model (เช่น Profile ที่ขยาย User)

## ตัวเลือก on_delete (สำคัญที่ต้องเลือกให้ถูก)

```text
CASCADE   → delete related objects too (delete author → delete their books)
PROTECT   → prevent deletion if related objects exist (raises an error)
SET_NULL  → set the FK to NULL (requires null=True) — keep the books, orphan them
SET_DEFAULT / SET(...) → set to a default/computed value
RESTRICT  → similar to PROTECT, with nuances
```

## การ query ข้ามความสัมพันธ์

```python
# traverse relationships in queries with __ (double underscore)
Book.objects.filter(author__name="Tolkien")        # books whose author's name is Tolkien
Article.objects.filter(tags__name="python")         # articles tagged 'python'
```

## ทำไมจึงสำคัญ

การสร้างโมเดลความสัมพันธ์ให้ถูกต้องเป็นพื้นฐานในการทำงานกับข้อมูลเชิงสัมพันธ์ใน Django — แทบทุก application จริงมี entity ที่เกี่ยวข้องกัน (users กับ posts, orders กับ items, articles กับ tags) ดังนั้นการเข้าใจ field type ความสัมพันธ์สามแบบจึงเป็นความรู้ที่จำเป็นในการใช้งานประจำวัน

การรู้ว่าเมื่อไรควรใช้แต่ละแบบ — **ForeignKey** สำหรับ one-to-many (พบบ่อยที่สุด เช่นหนังสือที่เป็นของผู้เขียน), **ManyToManyField** สำหรับ many-to-many (เช่นบทความและแท็ก โดย Django จัดการ join table อัตโนมัติ) และ **OneToOneField** สำหรับ one-to-one (เช่นการขยาย user ด้วย profile) — จำเป็นต่อการออกแบบ data model ที่ไม่ธรรมดาใด ๆ

ORM ทำให้ข้อมูลที่เกี่ยวข้องกัน **เป็น Python และสะดวก** (เข้าถึง `book.author` และ `author.books.all()` ได้อย่างเป็นธรรมชาติ, query ข้ามความสัมพันธ์ด้วย `__`) แต่สองด้านต้องระมัดระวัง: การเลือกพฤติกรรม **`on_delete`** ให้ถูกต้อง (การตัดสินใจที่จำเป็นและมีผลตามมา — `CASCADE` ลบ object ที่เกี่ยวข้อง, `PROTECT` ป้องกันการลบ, `SET_NULL` ทำให้กลายเป็น orphan — เลือกผิดอาจทำให้ข้อมูลสูญหายโดยไม่ตั้งใจหรือเกิด integrity error) และการใช้ `related_name` เพื่อการเข้าถึง reverse ที่ชัดเจน

การเข้าใจการสร้างโมเดลความสัมพันธ์, ตัวเลือก on_delete และการ query ข้ามความสัมพันธ์เป็นหัวใจสำคัญในการสร้าง data model ของ Django ที่ถูกต้องและออกแบบมาดี และมันเชื่อมโยงโดยตรงกับการ optimize query (เพราะการ traverse ความสัมพันธ์อย่างไม่ระวังทำให้เกิดปัญหา N+1) ทำให้มันเป็นความรู้ทั้งพื้นฐานและถูกถามบ่อย