Como você modela relacionamentos no ORM?

Question

Accepted Answer

O ORM do Django modela os três relacionamentos fundamentais de banco de dados com tipos de campo dedicados: **ForeignKey** (um-para-muitos), **ManyToManyField** (muitos-para-muitos) e **OneToOneField** (um-para-um). Estes definem como as tabelas se relacionam e permitem acesso Pythônico aos objetos relacionados.

## ForeignKey — um-para-muitos (o mais comum)

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

Uma `ForeignKey` modela "muitos livros pertencem a um autor". O comportamento de `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, etc.) é **obrigatório** e define o que acontece com os livros se o autor for excluído.

## ManyToManyField — muitos-para-muitos

```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 cria automaticamente a **tabela de junção** por trás de um `ManyToManyField` — você apenas usa `.add()`, `.remove()`, `.all()`. (Para dados extras no relacionamento, use um modelo `through`.)

## OneToOneField — um-para-um

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

Um `OneToOneField` reforça um vínculo estrito um-para-um — comumente usado para estender um modelo (ex: um Profile estendendo um User).

## Opções de on_delete (importante escolher corretamente)

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

## Consultando entre relacionamentos

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

## Por que isso importa

Modelar relacionamentos corretamente é fundamental para trabalhar com dados relacionais no Django — praticamente toda aplicação real tem entidades relacionadas (usuários e posts, pedidos e itens, artigos e tags), então entender os três tipos de campo de relacionamento é conhecimento essencial do dia a dia.

Saber quando usar cada um — **ForeignKey** para um-para-muitos (o mais comum, como livros pertencendo a um autor), **ManyToManyField** para muitos-para-muitos (como artigos e tags, com o Django gerenciando automaticamente a tabela de junção) e **OneToOneField** para um-para-um (como estender um usuário com um perfil) — é necessário para projetar qualquer modelo de dados não trivial.

O ORM torna dados relacionados **Pythônicos e convenientes** (acessando `book.author` e `author.books.all()` naturalmente, consultando entre relacionamentos com `__`), mas dois aspectos exigem cuidado: escolher o **comportamento correto de `on_delete`** (uma decisão obrigatória e consequente — `CASCADE` exclui objetos relacionados, `PROTECT` impede exclusão, `SET_NULL` os torna órfãos — errar pode causar perda acidental de dados ou erros de integridade) e usar `related_name` para acesso claro ao relacionamento inverso.

Compreender modelagem de relacionamentos, as opções de on_delete e consultas entre relacionamentos é essencial para construir modelos de dados Django corretos e bem projetados, e se conecta diretamente à otimização de consultas (já que percorrer relacionamentos ingenuamente causa problemas N+1), tornando-o tanto conhecimento fundamental quanto frequentemente testado.