Cum modelezi relațiile în ORM?

Question

Accepted Answer

ORM-ul Django modelează cele trei relații fundamentale ale bazei de date cu tipuri de câmpuri dedicate: **ForeignKey** (unu-la-mulți), **ManyToManyField** (mulți-la-mulți), și **OneToOneField** (unu-la-unu). Acestea definesc modul în care tabelele se raportează și îți oferă acces Pythonic la obiecte conexe.

## ForeignKey — unu-la-mulți (cel mai comun)

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

O `ForeignKey` modelează "multe cărți aparțin unui autor". Comportamentul `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, etc.) este **obligatoriu** și definește ce se întâmplă cu cărțile dacă autorul este șters.

## ManyToManyField — mulți-la-mulți

```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 creează automat **tabela de joncțiune** în spatele unui `ManyToManyField` — pur și simplu folosești `.add()`, `.remove()`, `.all()`. (Pentru date suplimentare în relație, folosește un model `through`.)

## OneToOneField — unu-la-unu

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

O `OneToOneField` impune o legătură strict unu-la-unu — utilizată în mod obișnuit pentru a extinde un model (de exemplu, un Profile extinzând un User).

## Opțiuni on_delete (important de ales corect)

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

## Interogări prin relații

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

## De ce conteaza

Modelarea corectă a relațiilor este fundamentală pentru lucrul cu date relaționale în Django — aproape fiecare aplicație reală are entități conexe (utilizatori și postări, comenzi și articole, articole și etichete), deci înțelegerea celor trei tipuri de câmpuri de relație este cunoaștere esențială de zi cu zi.

Știind când să folosești fiecare — **ForeignKey** pentru unu-la-mulți (cel mai comun, cum ar fi cărțile aparținând unui autor), **ManyToManyField** pentru mulți-la-mulți (cum ar fi articolele și etichetele, cu Django gestionând automat tabela de joncțiune), și **OneToOneField** pentru unu-la-unu (cum ar fi extinderea unui utilizator cu un profil) — este necesar pentru a proiecta orice model de date non-trivial.

ORM-ul face datele conexe **Pythonic și convenabile** (accesând `book.author` și `author.books.all()` natural, interogând prin relații cu `__`), dar două aspecte necesită atenție: alegerea comportamentului **`on_delete` corect** (o decizie obligatorie și importantă — `CASCADE` șterge obiecte conexe, `PROTECT` împiedică ștergerea, `SET_NULL` le lasă orfane — greșind se poate provoca pierdere accidentală de date sau erori de integritate), și utilizarea `related_name` pentru acces clar în sens invers.

Înțelegerea modelării relațiilor, a opțiunilor on_delete și a interogărilor prin relații este esențială pentru construirea modelelor de date Django corecte și bine proiectate, și se conectează direct la optimizarea interogărilor (din moment ce traversarea relațiilor în mod naiv provoacă probleme N+1), făcând-o atât cunoaștere fundamentală, cât și frecvent testată.