Hur modellerar du relationer i ORM:en?

Question

Accepted Answer

Django's ORM modellerar de tre grundläggande databasrelationerna med dedikerade fälttyper: **ForeignKey** (en-till-många), **ManyToManyField** (många-till-många) och **OneToOneField** (en-till-en). Dessa definierar hur tabeller förhåller sig till varandra och ger dig Pythonic-åtkomst till relaterade objekt.

## ForeignKey — en-till-många (den vanligaste)

```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` modellerar "många böcker tillhör en författare." Beteendet `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL` osv.) är **obligatoriskt** och definierar vad som händer med böckerna om författaren tas bort.

## ManyToManyField — många-till-många

```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 skapar automatiskt **join-tabellen** bakom en `ManyToManyField` — du använder bara `.add()`, `.remove()`, `.all()`. (För extra data på relationen, använd en `through`-modell.)

## OneToOneField — en-till-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` tillämpar en strikt en-till-en-länk — ofta använd för att utöka en modell (t.ex. en Profile som utökar en User).

## on_delete-alternativ (viktigt att välja 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
```

## Fråga på tvärs av 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'
```

## Varför det är viktigt

Att modellera relationer korrekt är grundläggande för att arbeta med relationell data i Django — nästan varje verklig applikation har relaterade enheter (användare och inlägg, beställningar och artiklar, artiklar och taggar), så att förstå de tre relationsfälttyperna är väsentlig kunskap för vardagen.

Att veta när man ska använda var och en — **ForeignKey** för en-till-många (den vanligaste, som böcker som tillhör en författare), **ManyToManyField** för många-till-många (som artiklar och taggar, med Django auto-hantering av join-tabellen) och **OneToOneField** för en-till-en (som att utöka en användare med en profil) — är nödvändigt för att designa någon icke-trivial datamodell.

ORM:en gör relaterad data **Pythonic och bekväm** (åtkomst till `book.author` och `author.books.all()` naturligt, fråga på tvärs av relationer med `__`), men två aspekter kräver försiktighet: att välja det korrekta **`on_delete`-beteendet** (ett obligatoriskt, konsekventiallt beslut — `CASCADE` raderar relaterade objekt, `PROTECT` förhindrar borttagning, `SET_NULL` föräldralös dem — att få det fel kan orsaka oavsiktlig dataförlust eller integritetsfel) och att använda `related_name` för tydlig omvänd åtkomst.

Att förstå relationsmodellering, on_delete-alternativen och frågor på tvärs av relationer är centralt för att bygga korrekta, väl utformade Django-datamodeller, och det är direkt kopplat till frågeoptimiering (eftersom att korsa relationer naivt orsakar N+1-problem), vilket gör det både grundläggande och ofta testad kunskap.