Hvordan modellerer du relasjoner i ORM?

Question

Accepted Answer

Django's ORM modellerer de tre grunnleggende databaserelasjonene med dedikerte felttyper: **ForeignKey** (en-til-mange), **ManyToManyField** (mange-til-mange), og **OneToOneField** (en-til-en). Disse definerer hvordan tabeller forholder seg til hverandre og gir deg Pythonisk tilgang til relaterte objekter.

## ForeignKey — en-til-mange (den vanligste)

```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øker tilhører en forfatter." Oppførselen `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, etc.) er **påkrevd** og definerer hva som skjer med bøkene 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 oppretter automatisk **sammenføyingstabellen** bak en `ManyToManyField` — du bruker bare `.add()`, `.remove()`, `.all()`. (For ekstra data på relasjonen, bruk en `through`-modell.)

## 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åndhever en streng en-til-en-kobling — vanligvis brukt for å utvide en modell (f.eks. en Profile som utvider en User).

## on_delete-alternativer (viktig å velge riktig)

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

## Spørring på tvers av relasjoner

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

Å modellere relasjoner korrekt er grunnleggende for arbeid med relasjonelle data i Django — nesten alle virkelige applikasjoner har relaterte enheter (brukere og innlegg, bestillinger og varer, artikler og tagger), så å forstå de tre relasjonsfeltypene er essensiell daglig kunnskap.

Å vite når du skal bruke hver enkelt — **ForeignKey** for en-til-mange (den vanligste, som bøker som tilhører en forfatter), **ManyToManyField** for mange-til-mange (som artikler og tagger, med Django som automatisk håndterer sammenføyingstabellen), og **OneToOneField** for en-til-en (som å utvide en bruker med en profil) — er nødvendig for å designe en ikke-triviell datamodell.

ORM gjør relaterte data **Pythonisk og praktisk** (tilgang til `book.author` og `author.books.all()` naturlig, spørring på tvers av relasjoner med `__`), men to aspekter krever oppmerksomhet: valg av riktig **`on_delete`-oppførsel** (en påkrevd, konsekventiell beslutning — `CASCADE` sletter relaterte objekter, `PROTECT` forhindrer sletting, `SET_NULL` etterlater dem som foreldreløse — å få det galt kan forårsake utilsiktet datatap eller integritetsfeil), og bruk av `related_name` for klar revers tilgang.

Å forstå relasjonmodellering, on_delete-alternativene og spørring på tvers av relasjoner er kjernen i å bygge korrekte, veldesignede Django-datamodeller, og det har direkte forbindelse til spørringoptimalisering (siden traversering av relasjoner naivt forårsaker N+1-problemer), noe som gjør det både grunnleggende og hyppig testet kunnskap.