Hvordan modellerer du relationer i ORM'en?

Question

Accepted Answer

Django's ORM modellerer de tre grundlæggende databaserelationer med dedikerede felttyper: **ForeignKey** (en-til-mange), **ManyToManyField** (mange-til-mange) og **OneToOneField** (en-til-en). Disse definerer, hvordan tabeller relaterer sig, og giver dig Pythonic adgang til relaterede objekter.

## ForeignKey — en-til-mange (den mest almindelige)

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

En `ForeignKey` modellerer "mange bøger tilhører en forfatter." `on_delete`-adfærden (`CASCADE`, `PROTECT`, `SET_NULL` osv.) er **påkrævet** og definerer, hvad der sker med bøgerne, hvis forfatteren slettes.

## ManyToManyField — mange-til-mange

```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 opretter automatisk **join-tabellen** bag en `ManyToManyField` — du bruger bare `.add()`, `.remove()`, `.all()`. (For ekstra data om relationen skal du bruge en `through`-model.)

## OneToOneField — en-til-en

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

En `OneToOneField` håndhæver et strikt en-til-en-link — almindeligvis brugt til at udvide en model (f.eks. en Profile, der udvider en User).

## on_delete-muligheder (vigtigt at vælge korrekt)

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

## Forespørgsler på tværs af relationer

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

## Hvorfor det betyder noget

At modellere relationer korrekt er fundamental for at arbejde med relationelle data i Django — næsten enhver rigtig applikation har relaterede entiteter (brugere og indlæg, ordrer og elementer, artikler og tags), så forståelse af de tre relationsfelttyper er væsentlig, daglig viden.

At vide, hvornår man skal bruge hver enkelt — **ForeignKey** for en-til-mange (den mest almindelige, som bøger, der tilhører en forfatter), **ManyToManyField** for mange-til-mange (som artikler og tags, med Django, der automatisk administrerer join-tabellen) og **OneToOneField** for en-til-en (som at udvide en bruger med en profil) — er nødvendigt for at designe enhver ikke-triviel datamodel.

ORM'en gør relaterede data **Pythonic og bekvem** (adgang til `book.author` og `author.books.all()` naturligt, forespørgsler på tværs af relationer med `__`), men to aspekter kræver opmærksomhed: valg af korrekt **`on_delete`-adfærd** (en påkrævet, væsentlig beslutning — `CASCADE` sletter relaterede objekter, `PROTECT` forhindrer sletning, `SET_NULL` efterlader dem som forældreløse — at få det forkert kan forårsage utilsigtet datatab eller integritetssfejl) og brug af `related_name` til klar omvendt adgang.

Forståelse af relationmodellering, `on_delete`-mulighederne og forespørgsler på tværs af relationer er kernestof for at bygge korrekte, veldesignede Django-datamodeller, og det forbinder sig direkte til forespørgselsoptimering (da naiv gennemgang af relationer forårsager N+1-problemer), hvilket gør det både grundlæggende og hyppigt testeret viden.