Maîtriser les modèles Django et l'ORM

Ecrire des requêtes SQL, c’est une tâche qui peut vite devenir répétitive, complexe et source d’erreurs de sécurité.

C’est ici que l’ORM (Object-Relational Mapper) de Django entre en scène. C’est l’une des fonctionnalités les plus puissantes du framework, conçue pour vous faire gagner en productivité et en sérénité.

La Philosophie de l’ORM Django : C’est quoi au juste ?

Un ORM est une technique de programmation qui crée une “couche d’abstraction” entre votre code (orienté objet, en Python) et la base de données (relationnelle, en SQL).

Au lieu d’écrire : SELECT * FROM blog_post WHERE status = 'published';

Vous écrivez du Python : Post.objects.filter(status='published')

La magie de l’ORM, c’est de traduire ce code Python en une requête SQL optimisée et sécurisée pour la base de données que vous avez choisie (PostgreSQL, MySQL, SQLite, etc.).

Les avantages sont immenses :

• Productivité : Vous écrivez du Python, pas du SQL. C’est plus rapide, plus intuitif et mieux intégré au reste de votre application.
• Portabilité : Changez de base de données (par exemple, de SQLite en développement à PostgreSQL en production) sans modifier votre code. L’ORM s’occupe de la traduction.
• Sécurité : L’ORM de Django échappe automatiquement les paramètres, vous protégeant ainsi contre les attaques par injection SQL, l’une des failles de sécurité les plus courantes.
• Lisibilité : Votre code est plus clair et plus facile à maintenir, car la logique de données est exprimée en objets Python.

Définir la Structure avec les Modèles Django

Dans Django, un modèle est la source unique et définitive d’information sur vos données. Il contient les champs et les comportements essentiels des données que vous stockez. Chaque modèle correspond généralement à une seule table de base de données.

Pour créer un modèle, on définit une classe qui hérite de django.db.models.Model.

Imaginons que nous construisions un blog. Un bon point de départ serait un modèle Post :

# dans le fichier models.py de votre application
from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    published_date = models.DateTimeField(auto_now_add=True)
    is_published = models.BooleanField(default=True)

    def __str__(self):
        return self.title

Chaque attribut de la classe représente un champ dans la base de données. Django utilisera cette définition pour créer la table blog_post (en supposant que notre application s’appelle blog).

Les Types de Champs Essentiels

Django propose une large gamme de types de champs pour couvrir tous vos besoins. Voici les plus courants :

• CharField : Pour les chaînes de caractères de petite à moyenne taille. L’argument max_length est obligatoire. Idéal pour les titres, les noms, etc.
• TextField : Pour les textes longs, comme le contenu d’un article de blog. Pas de limite de taille (au niveau de Django).
• IntegerField, FloatField, DecimalField : Pour stocker des nombres (entiers, à virgule flottante, décimaux de précision fixe).
• BooleanField : Pour les valeurs Vrai/Faux. Il est stocké en tant que true/false en base de données. default=False est souvent une bonne pratique.
• DateTimeField, DateField, TimeField : Pour les dates et heures.
  • auto_now=True : Met à jour le champ à chaque sauvegarde du modèle. Parfait pour un champ last_updated.
  • auto_now_add=True : Ne sauvegarde la date et l’heure qu’à la création de l’objet. Idéal pour un champ creation_date.
• EmailField, URLField : Des CharField avec une validation intégrée pour les formats d’email et d’URL.

Les Relations entre Modèles

C’est ici que la puissance de l’ORM brille vraiment. Les applications réelles ont des données interconnectées. Un article a un auteur, un produit a une catégorie, etc.

ForeignKey (Relation Un-à-Plusieurs)

Utilisez ForeignKey quand un objet d’un modèle est lié à un seul objet d’un autre modèle. C’est la relation la plus courante.

Exemple : Un auteur peut écrire plusieurs articles, mais un article n’a qu’un seul auteur.

from django.contrib.auth.models import User

class Author(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField()

    def __str__(self):
        return self.user.username

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey(Author, on_delete=models.CASCADE) # La relation !

    def __str__(self):
        return self.title

L’argument on_delete=models.CASCADE est crucial : il dit à Django que si un auteur est supprimé, tous ses articles doivent également être supprimés.

ManyToManyField (Relation Plusieurs-à-Plusieurs)

Utilisez ManyToManyField quand un objet peut être lié à plusieurs objets d’un autre modèle, et vice-versa.

Exemple : Un article peut avoir plusieurs tags (catégories), et un tag peut être associé à plusieurs articles.

class Tag(models.Model):
    name = models.CharField(max_length=50, unique=True)

    def __str__(self):
        return self.name

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    tags = models.ManyToManyField(Tag) # La relation !

    def __str__(self):
        return self.title

Django créera automatiquement une table intermédiaire en base de données pour gérer cette relation complexe. Vous n’avez pas à vous en soucier !

OneToOneField (Relation Un-à-Un)

Moins courant, mais très utile. Utilisez OneToOneField quand un objet d’un modèle est lié à un et un seul autre objet. C’est comme une ForeignKey avec une contrainte d’unicité.

Exemple : Étendre le modèle User de Django avec un profil utilisateur spécifique. Chaque User n’a qu’un seul UserProfile.

from django.contrib.auth.models import User

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE) # La relation !
    avatar = models.ImageField(upload_to='avatars/')
    website = models.URLField(blank=True)

    def __str__(self):
        return self.user.username

Appliquer les Changements : les Migrations Django

Vous avez modifié vos models.py, mais comment la base de données est-elle mise au courant de ces changements ? Grâce au système de migrations Django.

C’est un système de contrôle de version pour votre schéma de base de données.

1. Générer les fichiers de migration : Chaque fois que vous modifiez vos modèles (ajoutez un champ, supprimez un modèle, etc.), vous devez exécuter cette commande :

   python manage.py makemigrations

   Django compare vos modèles actuels à leur état précédent (stocké dans les derniers fichiers de migration) et génère un nouveau fichier de migration dans le dossier migrations/ de votre application. Ce fichier contient le code Python pour appliquer vos changements.

2. Appliquer les migrations à la base de données : Cette commande lit les fichiers de migration qui n’ont pas encore été appliqués et exécute les changements correspondants sur votre base de données.

   python manage.py migrate

Ce processus en deux étapes est incroyablement robuste. Il vous permet de développer votre schéma de données de manière itérative et sécurisée, et de le déployer de manière fiable sur d’autres environnements.

Conclusion

L’ORM et les modèles sont le cœur de toute application Django. Ils fournissent un moyen puissant, sécurisé et productif d’interagir avec votre base de données en utilisant uniquement du code Python.

En maîtrisant la définition des modèles, les différents types de champs et, surtout, les relations ForeignKey, ManyToManyField et OneToOneField, vous avez les fondamentaux pour construire la structure de données de n’importe quelle application web.