Comment fonctionnent les modèles et l'ORM ?

Question

Accepted Answer

Un **modèle** est une classe Python qui définit la structure de vos données — chaque modèle correspond à une table de base de données, et chaque attribut à une colonne. L'**ORM (Object-Relational Mapper)** vous permet d'interagir avec la base de données en utilisant des objets et des méthodes Python au lieu d'écrire du SQL brut.

## Définir un modèle

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

Chaque champ de modèle correspond à une colonne de base de données avec un type approprié. L'exécution des migrations crée la table correspondante — vous n'écrivez jamais `CREATE TABLE` vous-même.

## CRUD avec l'ORM (pas de 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()
```

L'ORM traduit automatiquement ces appels Python en SQL. Les recherches de champs (`__icontains`, `__gte`, `__in`, etc.) expriment les conditions WHERE de manière pythonique.

## Pourquoi un ORM ? Avantages et compromis

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

## Les modèles sont l'unique source de vérité (DRY)

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

## Pourquoi c'est important

Les modèles et l'ORM sont au cœur de Django — c'est comment vous définissez et travaillez avec les données de votre application, qui est le cœur de la plupart des applications web.

Les comprendre est une connaissance essentielle quotidienne : les modèles définissent la structure de vos données (mappant les classes aux tables, les attributs aux colonnes) et servent d'**unique source de vérité** qui conduit le schéma de base de données, l'interface admin, les formulaires et les sérialiseurs API (la philosophie DRY).

L'ORM vous permet d'écrire les opérations de base de données en **Python propre et lisible au lieu de SQL**, avec des avantages majeurs : la portabilité de la base de données (le même code s'exécute sur différentes bases de données), l'intégration étroite avec le reste de Django, et surtout la **sécurité** (il utilise des requêtes paramétrées par défaut, prévenant l'injection SQL).

Savoir comment définir des modèles avec des champs appropriés, effectuer des opérations CRUD et interroger avec la syntaxe de recherche de l'ORM est fondamental pour construire n'importe quelle application Django.

Également important est la conscience du **compromis** de l'ORM — que les requêtes pratiques peuvent devenir inefficaces (le problème N+1) sans attention — ce qui conduit à des techniques d'optimisation.

La couche modèle/ORM est où les applications Django passent une grande partie de leur logique, la rendant essentielle et incontournable.