Jak modelujesz relacje w ORM?

Question

Accepted Answer

Django ORM modeluje trzy fundamentalne relacje w bazie danych za pomocą dedykowanych typów pól: **ForeignKey** (jeden-do-wielu), **ManyToManyField** (wiele-do-wielu) i **OneToOneField** (jeden-do-jednego). Definiują one, jak tabele się relates i dają Ci pythoniczny dostęp do powiązanych obiektów.

## ForeignKey — jeden-do-wielu (najczęstszy przypadek)

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

`ForeignKey` modeluje "wiele książek należy do jednego autora". Zachowanie `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, itd.) jest **wymagane** i definiuje, co się dzieje z książkami, jeśli autor zostanie usunięty.

## ManyToManyField — wiele-do-wielu

```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 automatycznie tworzy **tabelę łączeniową** za `ManyToManyField` — po prostu używasz `.add()`, `.remove()`, `.all()`. (Aby dodać dodatkowe dane do relacji, użyj modelu `through`.)

## OneToOneField — jeden-do-jednego

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

`OneToOneField` wymusza ścisłą relację jeden-do-jednego — najczęściej używane do rozszerzenia modelu (np. Profile rozszerzający User).

## Opcje on_delete (ważne, aby wybrać prawidłowo)

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

## Zapytania na relacjach

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

## Dlaczego to ważne

Poprawne modelowanie relacji jest fundamentalne dla pracy z danymi relacyjnymi w Django — prawie każda rzeczywista aplikacja ma powiązane byty (użytkownicy i posty, zamówienia i produkty, artykuły i tagi), dlatego zrozumienie trzech typów pól relacji jest niezbędną codzienną wiedzą.

Wiedza, kiedy używać każdego — **ForeignKey** dla jeden-do-wielu (najczęstszy przypadek, jak książki należące do autora), **ManyToManyField** dla wiele-do-wielu (jak artykuły i tagi, z Django automatycznie zarządzającą tabelą łączeniową) i **OneToOneField** dla jeden-do-jednego (jak rozszerzenie użytkownika profilem) — jest niezbędna do projektowania każdego nietrywialnego modelu danych.

ORM czyni dane powiązane **pythoniczymi i wygodnymi** (dostęp do `book.author` i `author.books.all()` naturalnie, zapytania na relacjach z `__`), ale dwa aspekty wymagają ostrożności: wybór prawidłowego **zachowania `on_delete`** (wymagana, znacząca decyzja — `CASCADE` usuwa powiązane obiekty, `PROTECT` zapobiega usunięciu, `SET_NULL` pozostawia je sierocie — błąd może spowodować przypadkową utratę danych lub błędy integralności) i użycie `related_name` do jasnego dostępu wstecz.

Zrozumienie modelowania relacji, opcji on_delete i zapytań na relacjach krzyżowych jest kluczowe do budowania poprawnych, dobrze zaprojektowanych modeli danych Django i bezpośrednio wiąże się z optymalizacją zapytań (ponieważ naiwne przechodzenie relacji powoduje problemy N+1), czyniąc to zarówno wiedzą fundamentalną, jak i często testowaną.