Bạn mô hình hóa quan hệ trong ORM như thế nào?

Question

Accepted Answer

ORM của Django mô hình hóa ba quan hệ database cơ bản với các kiểu field chuyên dụng: **ForeignKey** (một-nhiều), **ManyToManyField** (nhiều-nhiều), và **OneToOneField** (một-một). Chúng định nghĩa cách các bảng liên hệ với nhau và cho bạn truy cập theo phong cách Python tới các đối tượng liên quan.

## ForeignKey — một-nhiều (phổ biến nhất)

```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,        # điều gì xảy ra nếu author bị xóa
        related_name="books",            # truy cập chiều ngược: author.books
    )
```

```python
# truy cập đối tượng liên quan một cách tự nhiên:
book.author                # Author mà book này thuộc về (chiều xuôi)
author.books.all()         # tất cả Book của author này (chiều ngược, qua related_name)
```

Một `ForeignKey` mô hình hóa "nhiều book thuộc về một author". Hành vi `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, v.v.) là **bắt buộc** và định nghĩa điều gì xảy ra với các book nếu author bị xóa.

## ManyToManyField — nhiều-nhiều

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

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

```python
article.tags.add(tag1, tag2)        # liên kết các tag
article.tags.all()                   # tất cả tag trên article này
tag.articles.all()                   # tất cả article có tag này (chiều ngược)
```

Django tự động tạo **bảng join** đằng sau một `ManyToManyField` — bạn chỉ cần dùng `.add()`, `.remove()`, `.all()`. (Để có thêm dữ liệu trên quan hệ, dùng một model `through`.)

## OneToOneField — một-một

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

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)   # một profile cho mỗi user
    bio = models.TextField()
```

Một `OneToOneField` áp đặt một liên kết một-một nghiêm ngặt — thường dùng để mở rộng một model (vd: một Profile mở rộng một User).

## Các tùy chọn on_delete (quan trọng phải chọn đúng)

```text
CASCADE   → xóa luôn các đối tượng liên quan (xóa author → xóa các book của họ)
PROTECT   → ngăn việc xóa nếu còn đối tượng liên quan (báo lỗi)
SET_NULL  → đặt FK thành NULL (cần null=True) — giữ các book, để chúng mồ côi
SET_DEFAULT / SET(...) → đặt thành giá trị mặc định/được tính
RESTRICT  → tương tự PROTECT, với những khác biệt tinh tế
```

## Truy vấn xuyên quan hệ

```python
# duyệt quan hệ trong truy vấn với __ (hai dấu gạch dưới)
Book.objects.filter(author__name="Tolkien")        # book có author tên là Tolkien
Article.objects.filter(tags__name="python")         # article được gắn tag 'python'
```

## Tại sao điều này quan trọng

Mô hình hóa quan hệ đúng cách là nền tảng khi làm việc với dữ liệu quan hệ trong Django — gần như mọi ứng dụng thực đều có các thực thể liên quan (user và post, đơn hàng và item, article và tag), nên hiểu ba kiểu field quan hệ là kiến thức hàng ngày thiết yếu.

Biết khi nào dùng từng kiểu — **ForeignKey** cho một-nhiều (phổ biến nhất, như book thuộc về một author), **ManyToManyField** cho nhiều-nhiều (như article và tag, với Django tự quản lý bảng join), và **OneToOneField** cho một-một (như mở rộng một user với một profile) — là cần thiết để thiết kế bất kỳ mô hình dữ liệu không tầm thường nào.

ORM làm cho dữ liệu liên quan **theo phong cách Python và tiện lợi** (truy cập `book.author` và `author.books.all()` tự nhiên, truy vấn xuyên quan hệ với `__`), nhưng hai khía cạnh đòi hỏi cẩn thận: chọn đúng **hành vi `on_delete`** (một quyết định bắt buộc, hệ trọng — `CASCADE` xóa các đối tượng liên quan, `PROTECT` ngăn việc xóa, `SET_NULL` để chúng mồ côi — chọn sai có thể gây mất dữ liệu ngoài ý muốn hoặc lỗi toàn vẹn), và dùng `related_name` để truy cập chiều ngược rõ ràng.

Hiểu mô hình hóa quan hệ, các tùy chọn on_delete, và truy vấn xuyên quan hệ là cốt lõi để xây dựng các mô hình dữ liệu Django đúng đắn, thiết kế tốt, và nó kết nối trực tiếp với tối ưu truy vấn (vì duyệt quan hệ một cách ngây thơ gây vấn đề N+1), khiến nó vừa nền tảng vừa là kiến thức thường được hỏi.