Hoe model je relaties in de ORM?

Question

Accepted Answer

Django's ORM modelleert de drie fundamentele databaserelaties met toegewijde veldtypen: **ForeignKey** (één-naar-veel), **ManyToManyField** (veel-naar-veel), en **OneToOneField** (één-naar-één). Deze definiëren hoe tabellen gerelateerd zijn en geven je Pythonische toegang tot gerelateerde objecten.

## ForeignKey — één-naar-veel (het meest voorkomend)

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

Een `ForeignKey` modelleert "veel boeken behoren tot één auteur." Het `on_delete`-gedrag (`CASCADE`, `PROTECT`, `SET_NULL`, enz.) is **verplicht** en bepaalt wat er met de boeken gebeurt als de auteur wordt verwijderd.

## ManyToManyField — veel-naar-veel

```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 maakt automatisch de **join-tabel** achter een `ManyToManyField` aan — je gebruikt gewoon `.add()`, `.remove()`, `.all()`. (Voor extra gegevens over de relatie, gebruik een `through`-model.)

## OneToOneField — één-naar-één

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

Een `OneToOneField` zorgt voor een strikte één-naar-éénkoppeling — veel gebruikt om een model uit te breiden (bijv. een Profile die een User uitbreidt).

## on_delete-opties (belangrijk om correct te kiezen)

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

## Queryen over relaties heen

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

## Waarom het belangrijk is

Relaties correct modelleren is fundamenteel voor het werken met relationele gegevens in Django — vrijwel elke echte applicatie heeft gerelateerde entiteiten (gebruikers en berichten, bestellingen en items, artikelen en tags), dus het begrijpen van de drie relatieveldtypen is essentiële dagelijkse kennis.

Weten wanneer je welke gebruikt — **ForeignKey** voor één-naar-veel (het meest voorkomend, zoals boeken die bij een auteur horen), **ManyToManyField** voor veel-naar-veel (zoals artikelen en tags, waarbij Django de join-tabel automatisch beheert), en **OneToOneField** voor één-naar-één (zoals het uitbreiden van een gebruiker met een profiel) — is noodzakelijk voor het ontwerpen van een non-triviaal gegevensmodel.

De ORM maakt gerelateerde gegevens **Pythonisch en handig** (toegang tot `book.author` en `author.books.all()` op natuurlijke wijze, queryen over relaties heen met `__`), maar twee aspecten vereisen aandacht: het kiezen van het juiste **`on_delete`-gedrag** (een verplichte, belangrijke beslissing — `CASCADE` verwijdert gerelateerde objecten, `PROTECT` voorkomt verwijdering, `SET_NULL` verweest ze — het verkeerd doen kan onopzettelijk gegevensverlies of integriteitsfouten veroorzaken), en het gebruik van `related_name` voor duidelijke reverse-toegang.

Het begrijpen van relatiemodellering, de on_delete-opties, en cross-relationship queryen is essentieel voor het bouwen van correcte, goed ontworpen Django-gegevensmodellen, en het staat in direct verband met query-optimalisatie (aangezien het naïef traverseren van relaties N+1-problemen veroorzaakt), waardoor het zowel fundamentele als veelvuldig geteste kennis is.