¿Cómo modelan las relaciones en el ORM?

Question

Accepted Answer

El ORM de Django modela las tres relaciones de base de datos fundamentales con tipos de campo dedicados: **ForeignKey** (uno-a-muchos), **ManyToManyField** (muchos-a-muchos) y **OneToOneField** (uno-a-uno). Estos definen cómo se relacionan las tablas y te dan acceso pythónico a objetos relacionados.

## ForeignKey — uno-a-muchos (el más común)

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

Un `ForeignKey` modela "muchos libros pertenecen a un autor". El comportamiento `on_delete` (`CASCADE`, `PROTECT`, `SET_NULL`, etc.) es **requerido** y define qué sucede con los libros si se elimina el autor.

## ManyToManyField — muchos-a-muchos

```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 automáticamente la **tabla de unión** detrás de un `ManyToManyField` — simplemente usas `.add()`, `.remove()`, `.all()`. (Para datos adicionales en la relación, usa un modelo `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` refuerza un vínculo estricto uno-a-uno — comúnmente usado para extender un modelo (por ejemplo, un Profile extendiendo un User).

## Opciones de on_delete (importante elegir correctamente)

```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 a través de relaciones

```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 qué es importante

Modelar las relaciones correctamente es fundamental para trabajar con datos relacionales en Django — casi todas las aplicaciones reales tienen entidades relacionadas (usuarios y posts, órdenes e items, artículos y etiquetas), por lo que entender los tres tipos de campos de relación es conocimiento esencial cotidiano.

Saber cuándo usar cada uno — **ForeignKey** para uno-a-muchos (el más común, como libros que pertenecen a un autor), **ManyToManyField** para muchos-a-muchos (como artículos y etiquetas, con Django gestionando automáticamente la tabla de unión) y **OneToOneField** para uno-a-uno (como extender un usuario con un perfil) — es necesario para diseñar cualquier modelo de datos no trivial.

El ORM hace que los datos relacionados sean **pythónicos y convenientes** (accediendo a `book.author` y `author.books.all()` naturalmente, consultando a través de relaciones con `__`), pero dos aspectos requieren cuidado: elegir el comportamiento correcto de **`on_delete`** (una decisión requerida y consecuente — `CASCADE` elimina objetos relacionados, `PROTECT` previene la eliminación, `SET_NULL` los huerfana — hacerlo mal puede causar pérdida accidental de datos o errores de integridad), y usar `related_name` para acceso inverso claro.

Entender el modelado de relaciones, las opciones de on_delete y las consultas entre relaciones es fundamental para construir modelos de datos Django correctos y bien diseñados, y se conecta directamente con la optimización de consultas (ya que atravesar relaciones ingenuamente causa problemas N+1), lo que lo hace tanto conocimiento fundamental como frecuentemente evaluado.