Padem caraning nggene model hubungan ing ORM?

Question

IT Interview Practice · Accepted Answer

Django ORM model telung hubungan basis data sing fundamental kanthi dedicated field types: **ForeignKey** (one-to-many), **ManyToManyField** (many-to-many), lan **OneToOneField** (one-to-one). Iki nggagarisi padem tabel saling hubung lan menehi akses Pythonic menyang obyek sing ana hubungane.

## ForeignKey — one-to-many (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)
```

Satunggal `ForeignKey` model "kathah buku padha belong menyang panjang panulis." Perilaku `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, lsp.) **kudu ana** lan nggagarisi apa sing kedadi ing buku yen panulis diilangi.

## 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 kanthi otomatis nggawa **join table** ing mburine `ManyToManyField` — sampeyan mung nggunakake `.add()`, `.remove()`, `.all()`. (Kanggo data ekstra ing hubungan, gunakake 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()
```

Satunggal `OneToOneField` nginforsi strict one-to-one link — biasane digunakake kanggo nambah model (cth. Profile sing nambah User).

## Opsi on_delete (penting kanggo milih kanthi bener)

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

## Querying across relationships

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

## Ora penting

Model hubungan kanthi bener minangka fundamental kanggo makarya karo data relasional ing Django — moro-moro setiap aplikasi nyata duwe entitas sing ana hubungane (users lan posts, orders lan items, articles lan tags), mula ngerti telung tipe field hubungan minangka pengetahuan penting saben dina.

Ngerti kapan nggunakake saben-saben — **ForeignKey** kanggo one-to-many (paling umum, kaya buku belonging menyang panulis), **ManyToManyField** kanggo many-to-many (kaya articles lan tags, kanthi Django otomatis manage join table), lan **OneToOneField** kanggo one-to-one (kaya nambah user karo profile) — kudu kanggo design apa-apa non-trivial data model.

ORM nggawa related data **Pythonic lan convenient** (access `book.author` lan `author.books.all()` kanthi alami, querying across relationships karo `__`), nanging rong aspek kudu care: milih **`on_delete` behavior** sing bener (keputusan kudu ana, consequential — `CASCADE` ilangi related objects, `PROTECT` cegah deletion, `SET_NULL` orphan buku — nggawe salah bisa nyebab accidental data loss utawa integrity errors), lan nggunakake `related_name` kanggo clear reverse access.

Ngerti relationship modeling, opsi on_delete, lan cross-relationship querying minangka core kanggo bangun correct, well-designed Django data models, lan direct connect menyang query optimization (amarga traversing relationships naif nyebab N+1 problems), nggawa dadi foundational lan frequently-tested knowledge.

ForeignKey — one-to-many (paling umum)

ManyToManyField — many-to-many

OneToOneField — one-to-one

Opsi on_delete (penting kanggo milih kanthi bener)

Querying across relationships

Ora penting

Pitakon sing gegandhengan