Bagaimana Anda memodelkan hubungan dalam ORM?

Question

Accepted Answer

Django's ORM memodelkan tiga hubungan database fundamental dengan tipe field khusus: **ForeignKey** (one-to-many), **ManyToManyField** (many-to-many), dan **OneToOneField** (one-to-one). Ini mendefinisikan bagaimana tabel berhubungan dan memberi Anda akses Pythonic ke objek terkait.

## ForeignKey — one-to-many (yang paling umum)

```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` memodelkan "banyak buku milik satu penulis." Perilaku `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, dll) adalah **wajib** dan mendefinisikan apa yang terjadi pada buku jika penulis dihapus.

## 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 secara otomatis membuat **tabel join** di balik `ManyToManyField` — Anda hanya menggunakan `.add()`, `.remove()`, `.all()`. (Untuk data tambahan pada hubungan, gunakan model `through`.)

## 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` menegakkan tautan one-to-one yang ketat — biasanya digunakan untuk memperluas model (misalnya Profile memperluas User).

## Opsi on_delete (penting untuk dipilih dengan benar)

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

## Kueri melintasi 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 ini penting

Memodelkan hubungan dengan benar adalah fundamental untuk bekerja dengan data relasional di Django — hampir setiap aplikasi nyata memiliki entitas terkait (pengguna dan posting, pesanan dan item, artikel dan tag), jadi memahami tiga tipe field hubungan adalah pengetahuan sehari-hari yang penting.

Mengetahui kapan menggunakan masing-masing — **ForeignKey** untuk one-to-many (yang paling umum, seperti buku yang dimiliki penulis), **ManyToManyField** untuk many-to-many (seperti artikel dan tag, dengan Django mengelola tabel join secara otomatis), dan **OneToOneField** untuk one-to-one (seperti memperluas pengguna dengan profil) — diperlukan untuk merancang model data non-trivial.

ORM membuat data terkait **Pythonic dan nyaman** (mengakses `book.author` dan `author.books.all()` secara natural, kueri melintasi hubungan dengan `__`), tetapi dua aspek memerlukan perhatian: memilih **perilaku `on_delete` yang benar** (keputusan wajib dan berpengaruh — `CASCADE` menghapus objek terkait, `PROTECT` mencegah penghapusan, `SET_NULL` membuat mereka orphan — memilih dengan salah dapat menyebabkan hilangnya data atau kesalahan integritas), dan menggunakan `related_name` untuk akses reverse yang jelas.

Memahami pemodelan hubungan, opsi on_delete, dan kueri cross-relationship adalah inti untuk membangun model data Django yang benar dan dirancang dengan baik, dan itu secara langsung terhubung dengan optimasi kueri (karena melintasi hubungan secara naif menyebabkan masalah N+1), menjadikannya pengetahuan yang fundamental dan sering diuji.