¿Cómo funcionan los modelos y el ORM?

Question

Accepted Answer

Un **modelo** es una clase Python que define la estructura de tus datos — cada modelo se asigna a una tabla de base de datos, y cada atributo a una columna. El **ORM (Object-Relational Mapper)** te permite interactuar con la base de datos usando objetos y métodos Python en lugar de escribir SQL sin procesar.

## Definiendo un modelo

```python
from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)       # → VARCHAR column
    body = models.TextField()                        # → TEXT column
    published = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)  # set on creation
    views = models.IntegerField(default=0)

def __str__(self):
        return self.title                            # readable representation (admin, shell)
```

Cada campo del modelo se asigna a una columna de base de datos con un tipo apropiado. Ejecutar migraciones crea la tabla correspondiente — nunca escribes `CREATE TABLE` por ti mismo.

## CRUD con el ORM (sin SQL)

```python
# CREATE
article = Article.objects.create(title="Hello", body="...")

# READ — query with Python methods
Article.objects.all()                            # all rows → SELECT *
Article.objects.get(id=1)                         # one row by primary key
Article.objects.filter(published=True)            # WHERE published = true
Article.objects.filter(title__icontains="django") # WHERE title ILIKE '%django%'
Article.objects.exclude(views=0).order_by("-created_at")  # complex queries, chained

# UPDATE
article.title = "Updated"
article.save()
Article.objects.filter(published=False).update(published=True)  # bulk update

# DELETE
article.delete()
```

El ORM traduce estas llamadas Python en SQL automáticamente. Las búsquedas de campos (`__icontains`, `__gte`, `__in`, etc.) expresan condiciones WHERE de manera Pythónica.

## ¿Por qué es importante

```text
✓ Write database code in Python — no SQL, more readable, less error-prone
✓ Database-agnostic — the same code works on PostgreSQL, MySQL, SQLite
✓ SECURITY — parameterized queries by default → prevents SQL injection
✓ Integrates with migrations, admin, forms (define the model once)
⚠️ Trade-off: can generate inefficient queries (e.g. N+1) if used carelessly —
   sometimes you need select_related/prefetch_related or raw SQL for complex cases
```

## Los modelos son la única fuente de verdad (DRY)

```text
One model definition drives: the database schema (migrations), the admin interface,
ModelForms, and serializers (DRF) — define it once, reuse everywhere.
```

## Por qué es importante

Los modelos y el ORM son centrales en Django — son cómo defines e interactúas con los datos de tu aplicación, que es el corazón de la mayoría de aplicaciones web.

Entenderlos es conocimiento esencial del día a día: los modelos definen tu estructura de datos (asignando clases a tablas, atributos a columnas) y sirven como la **única fuente de verdad** que impulsa el esquema de la base de datos, la interfaz de administrador, formularios y serializadores de API (la filosofía DRY).

El ORM te permite escribir operaciones de base de datos en **Python limpio y legible en lugar de SQL**, con grandes beneficios: portabilidad de base de datos (el mismo código se ejecuta en diferentes bases de datos), integración estrecha con el resto de Django, y crucialmente **seguridad** (usa consultas parametrizadas por defecto, previniendo inyección SQL).

Saber cómo definir modelos con campos apropiados, realizar operaciones CRUD y hacer consultas con la sintaxis de búsqueda del ORM es fundamental para construir cualquier aplicación Django.
Igualmente importante es la conciencia del **compromiso** del ORM — que las consultas convenientes pueden volverse ineficientes (el problema N+1) sin cuidado — lo que lleva a técnicas de optimización.

La capa de modelo/ORM es donde las aplicaciones Django gastan gran parte de su lógica, convirtiéndola en material central e imprescindible de dominar.