Jak modelujete vztahy v ORM?

Question

Accepted Answer

Django ORM modeluje tři základní databázové vztahy s dedikovanými typy polí: **ForeignKey** (jeden-k-mnoha), **ManyToManyField** (mnoho-k-mnoha) a **OneToOneField** (jeden-k-jednomu). Ty definují, jak se tabulky vztahují, a dávají vám pythonovský přístup ke vztaženým objektům.

## ForeignKey — jeden-k-mnoha (nejčastější)

```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 "mnoho knih patří jednomu autorovi." Chování `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL` atd.) je **povinné** a definuje, co se stane s knihami, pokud je autor smazán.

## ManyToManyField — mnoho-k-mnoha

```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 automaticky vytvoří **spojovací tabulku** za `ManyToManyField` — jednoduše používáte `.add()`, `.remove()`, `.all()`. (Pro dodatečná data o vztahu použijte model `through`.)

## OneToOneField — jeden-k-jednomu

```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` vynucuje striktní vztah jeden-k-jednomu — běžně se používá k rozšíření modelu (např. profil rozšiřující uživatele).

## Možnosti on_delete (důležitý správný výběr)

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

## Dotazování přes vztahy

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

## Proč je to důležité

Správu modelování vztahů je zásadní pro práci s relačními daty v Django — téměř každá reálná aplikace má související entity (uživatele a příspěvky, objednávky a položky, články a tagy), takže porozumění třem typům polí vztahů je nezbytná každodenní znalost.

Znalost, kdy používat které — **ForeignKey** pro jeden-k-mnoha (nejčastější, jako knihy patřící autorovi), **ManyToManyField** pro mnoho-k-mnoha (jako články a tagy, přičemž Django automaticky spravuje spojovací tabulku) a **OneToOneField** pro jeden-k-jednomu (jako rozšíření uživatele profilem) — je nezbytná pro návrh jakéhokoli netriviálního datového modelu.

ORM činí související data **pythonovským a pohodlným** (přístup k `book.author` a `author.books.all()` přirozeně, dotazování přes vztahy s `__`), ale dva aspekty vyžadují péči: výběr správného chování **`on_delete`** (povinné, důsledkové rozhodnutí — `CASCADE` smaže související objekty, `PROTECT` zabrání smazání, `SET_NULL` je opustí — chybný výběr může způsobit náhodnou ztrátu dat nebo chyby integrity) a použití `related_name` pro jasný zpětný přístup.

Porozumění modelování vztahů, možnostem on_delete a dotazování mezi vztahy je ústředním bodem pro vytváření správných, dobře navržených datových modelů Django a přímo se to váže na optimalizaci dotazů (jelikož naivní procházení vztahů způsobuje problémy N+1), což z toho činí jak základní, tak často testovanou znalost.