Come modelli le relazioni nell'ORM?

Question

Accepted Answer

L'ORM di Django modella le tre relazioni fondamentali del database con tipi di campo dedicati: **ForeignKey** (uno-a-molti), **ManyToManyField** (molti-a-molti) e **OneToOneField** (uno-a-uno). Questi definiscono come le tabelle si relazionano e ti danno un accesso Pythonic agli oggetti correlati.

## ForeignKey — uno-a-molti (il più comune)

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

Una `ForeignKey` modella "molti libri appartengono a un autore." Il comportamento `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, ecc.) è **obbligatorio** e definisce cosa succede ai libri se l'autore viene eliminato.

## ManyToManyField — molti-a-molti

```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 crea automaticamente la **tabella di join** dietro un `ManyToManyField` — usi semplicemente `.add()`, `.remove()`, `.all()`. (Per dati extra sulla relazione, usa un modello `through`.)

## OneToOneField — uno-a-uno

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

Un `OneToOneField` applica un collegamento rigoroso uno-a-uno — comunemente usato per estendere un modello (es. un Profile che estende un User).

## Opzioni on_delete (importante scegliere correttamente)

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

## Interrogazione attraverso le relazioni

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

## Perché è importante

Modellare le relazioni correttamente è fondamentale per lavorare con dati relazionali in Django — quasi ogni applicazione reale ha entità correlate (utenti e post, ordini e articoli, articoli e tag), quindi comprendere i tre tipi di campo relazione è conoscenza essenziale quotidiana.

Sapere quando usare ciascuno — **ForeignKey** per uno-a-molti (il più comune, come libri che appartengono a un autore), **ManyToManyField** per molti-a-molti (come articoli e tag, con Django che gestisce automaticamente la tabella di join) e **OneToOneField** per uno-a-uno (come estendere un utente con un profilo) — è necessario per progettare qualsiasi modello di dati non banale.

L'ORM rende i dati correlati **Pythonic e convenienti** (accedendo a `book.author` e `author.books.all()` naturalmente, interrogando attraverso le relazioni con `__`), ma due aspetti richiedono attenzione: scegliere il corretto comportamento **`on_delete`** (una decisione obbligatoria, consequenziale — `CASCADE` elimina gli oggetti correlati, `PROTECT` previene l'eliminazione, `SET_NULL` li lascia orfani — sbagliare può causare perdita accidentale di dati o errori di integrità) e usare `related_name` per un accesso inverso chiaro.

Comprendere la modellazione delle relazioni, le opzioni on_delete e l'interrogazione cross-relazione è fondamentale per costruire modelli di dati Django corretti e ben progettati, e si collega direttamente all'ottimizzazione delle query (poiché attraversare le relazioni ingenuamente causa problemi N+1), rendendola sia conoscenza fondamentale che frequentemente testata.