Wie modellierst du Beziehungen im ORM?

Question

Accepted Answer

Djangos ORM modelliert die drei grundlegenden Datenbankbeziehungen mit speziellen Feldtypen: **ForeignKey** (eins-zu-viele), **ManyToManyField** (viele-zu-viele) und **OneToOneField** (eins-zu-eins). Diese definieren, wie Tabellen zueinander in Beziehung stehen, und geben dir pythonischen Zugriff auf verwandte Objekte.

## ForeignKey — eins-zu-viele (am häufigsten)

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

Ein `ForeignKey` modelliert "viele Bücher gehören zu einem Autor". Das `on_delete`-Verhalten (`CASCADE`, `PROTECT`, `SET_NULL`, etc.) ist **erforderlich** und definiert, was mit den Büchern passiert, wenn der Autor gelöscht wird.

## ManyToManyField — viele-zu-viele

```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 erstellt die **Join-Tabelle** hinter einem `ManyToManyField` automatisch — du nutzt einfach `.add()`, `.remove()`, `.all()`. (Für zusätzliche Daten auf der Beziehung verwendest du ein `through`-Modell.)

## OneToOneField — eins-zu-eins

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

Ein `OneToOneField` erzwingt eine strikte eins-zu-eins-Verbindung — häufig verwendet, um ein Modell zu erweitern (z.B. ein Profile, das einen User erweitert).

## on_delete-Optionen (wichtig, die richtige zu wählen)

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

## Abfragen über Beziehungen hinweg

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

## Warum es wichtig ist

Beziehungen korrekt zu modellieren ist grundlegend für die Arbeit mit relationalen Daten in Django — fast jede echte Anwendung hat verwandte Entitäten (Benutzer und Beiträge, Bestellungen und Artikel, Artikel und Tags), daher ist das Verständnis der drei Beziehungsfeldtypen wesentliches Alltagswissen.

Zu wissen, wann man jeden Typ verwendet — **ForeignKey** für eins-zu-viele (am häufigsten, wie Bücher, die zu einem Autor gehören), **ManyToManyField** für viele-zu-viele (wie Artikel und Tags, wobei Django die Join-Tabelle automatisch verwaltet) und **OneToOneField** für eins-zu-eins (wie ein Profil, das einen Benutzer erweitert) — ist notwendig für die Gestaltung jedes nichttrivialen Datenmodells.

Das ORM macht verwandte Daten **pythonisch und bequem** (Zugriff auf `book.author` und `author.books.all()` auf natürliche Weise, Abfragen über Beziehungen mit `__`), aber zwei Aspekte erfordern Sorgfalt: die Wahl des korrekten **`on_delete`-Verhaltens** (eine erforderliche, folgenreiche Entscheidung — `CASCADE` löscht verwandte Objekte, `PROTECT` verhindert das Löschen, `SET_NULL` verwaist sie — falsch gemacht kann es zu versehentlichem Datenverlust oder Integritätsfehlern führen) und die Verwendung von `related_name` für klaren umgekehrten Zugriff.

Das Verständnis von Beziehungsmodellierung, den on_delete-Optionen und beziehungsübergreifenden Abfragen ist grundlegend für die Erstellung korrekter, gut gestalteter Django-Datenmodelle und hängt direkt mit der Abfrageoptimierung zusammen (da das naive Durchlaufen von Beziehungen N+1-Probleme verursacht), wodurch es sowohl grundlegend als auch häufig geprüftes Wissen wird.