Bagaimanakah anda memodelkan hubungan dalam ORM?

Question

Accepted Answer

ORM Django memodelkan tiga hubungan pangkalan data asas dengan jenis medan khusus: **ForeignKey** (satu-ke-banyak), **ManyToManyField** (banyak-ke-banyak), dan **OneToOneField** (satu-ke-satu). Ini mentakrifkan cara jadual berkait dan memberi anda akses Pythonik kepada objek berkaitan.

## ForeignKey — satu-ke-banyak (yang paling biasa)

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

Satu `ForeignKey` memodelkan "banyak buku tergolong kepada satu pengarang." Tingkah laku `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, dll.) adalah **wajib** dan mentakrifkan apa yang berlaku kepada buku jika pengarang dipadamkan.

## ManyToManyField — banyak-ke-banyak

```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 secara automatik mencipta **jadual gabungan** di sebalik `ManyToManyField` — anda hanya menggunakan `.add()`, `.remove()`, `.all()`. (Untuk data tambahan pada hubungan itu, gunakan model `through`.)

## OneToOneField — satu-ke-satu

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

Satu `OneToOneField` menguatkuasakan pautan satu-ke-satu yang ketat — biasanya digunakan untuk memperluas model (cth. Profile memperluas User).

## Pilihan on_delete (penting untuk dipilih dengan betul)

```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
```

## Membuat pertanyaan merentasi hubungan

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

## Mengapa ia penting

Memodelkan hubungan dengan betul adalah asas untuk bekerja dengan data relasi dalam Django — hampir setiap aplikasi sebenar mempunyai entiti berkaitan (pengguna dan pos, pesanan dan item, artikel dan tag), jadi memahami tiga jenis medan hubungan adalah pengetahuan harian yang penting.

Mengetahui bila untuk menggunakan setiap satu — **ForeignKey** untuk satu-ke-banyak (yang paling biasa, seperti buku tergolong kepada pengarang), **ManyToManyField** untuk banyak-ke-banyak (seperti artikel dan tag, dengan Django mengurus jadual gabungan secara automatik), dan **OneToOneField** untuk satu-ke-satu (seperti memperluas pengguna dengan profil) — adalah perlu untuk mereka bentuk mana-mana model data yang bukan remeh.

ORM menjadikan data berkaitan **Pythonik dan mudah** (mengakses `book.author` dan `author.books.all()` secara semula jadi, membuat pertanyaan merentasi hubungan dengan `__`), tetapi dua aspek memerlukan berhati-hati: memilih **tingkah laku `on_delete`** yang betul (keputusan yang wajib dan berkesan — `CASCADE` memadam objek berkaitan, `PROTECT` mencegah pemadaman, `SET_NULL` menjadikannya yatim — tersilap boleh menyebabkan kehilangan data tidak sengaja atau ralat integriti), dan menggunakan `related_name` untuk akses songsang yang jelas.

Memahami pemodelan hubungan, pilihan on_delete, dan pertanyaan merentasi hubungan adalah teras untuk membina model data Django yang betul dan direka dengan baik, dan ia berkait terus dengan pengoptimuman pertanyaan (kerana merentasi hubungan secara naif menyebabkan masalah N+1), menjadikannya pengetahuan yang asas dan kerap diuji.