Utilisation de __(double underscore) dans Django ORM : champs relationnels et requêtes

Qu'est-ce que __(double underscore) ?

Dans Django, __(double underscore) est utilisé pour écrire des requêtes de base de données à travers des champs relationnels entre modèles. En d'autres termes, il permet d'accéder à des champs connectés d'autres tables ou de filtrer des données avec des conditions spécifiques.

Par exemple, lorsque deux modèles sont connectés par des relations telles que ForeignKey ou OneToOneField, nous pouvons accéder aux champs souhaités à travers cette relation. Ici, __ joue le rôle d'un "maillon" permettant de chaîner l'accès aux champs de différents modèles.

Exemple d'utilisation de __ dans les relations entre modèles

Considérons un exemple simple. Supposons que le modèle Profile soit relié au modèle User, et ce modèle utilisateur contient un champ appelé username. Nous pouvons filtrer certains profils dans le modèle Profile basé sur le username de l'utilisateur.

Définition des modèles :

from django.db import models
from django.contrib.auth.models import AbstractUser

class CustomUser(AbstractUser):
    pass

class Profile(models.Model):
    user = models.OneToOneField(CustomUser, on_delete=models.CASCADE)
    bio = models.TextField()

Dans cet exemple, le modèle Profile a une relation 1:1 avec CustomUser. Voyons maintenant comment accéder aux champs de CustomUser depuis Profile en utilisant __.

Requête utilisant __ :

# Filtrage des objets Profile basés sur le username de CustomUser
profiles = Profile.objects.filter(user__username='jesse')

Ici, user__username est la clé. user est le champ connecté au modèle CustomUser dans le modèle Profile, et pour accéder au champ username de ce champ, on utilise le __. Ainsi, nous pouvons récupérer des données dans le modèle Profile sur la base du champ username de CustomUser.

Applications variées de __

__ est souvent utilisé non seulement pour accéder aux champs, mais aussi pour imposer des conditions. Django offre plusieurs fonctionnalités de filtrage qui permettent de définir diverses conditions dans un queryset, dont beaucoup sont réalisées via __. Parmi les conditions les plus courantes, nous trouvons :

exact : trouve les valeurs qui correspondent exactement (c'est la valeur par défaut, donc peut être omis).
icontains : trouve les valeurs qui incluent sans distinction de majuscules et de minuscules.
gt, lt, gte, lte : conditions pour trouver des valeurs plus grandes ou plus petites (greater than, less than).
startswith, endswith : trouve les valeurs qui commencent ou se terminent par une chaîne spécifique.

Exemple : différentes conditions de filtrage

# Rechercher tous les profils dont l'email de CustomUser contient 'gmail.com'
profiles_with_gmail = Profile.objects.filter(user__email__icontains='gmail.com')

# Rechercher les profils de CustomUser avec un ID supérieur à 10
profiles_with_id_gt_10 = Profile.objects.filter(user__id__gt=10)

# Rechercher les profils de CustomUser dont le username commence par 'jesse'
profiles_starting_with_jesse = Profile.objects.filter(user__username__startswith='jesse')

Accès à plusieurs champs de relation via __

Une des fonctionnalités les plus puissantes de Django est la possibilité de naviguer à travers des relations multiples entre plusieurs modèles grâce à __ pour interroger les données. Par exemple, imaginons que le modèle Order soit lié à Profile, et que ce dernier soit également lié à CustomUser.

Exemple de modèle à multiples relations :

class Order(models.Model):
    profile = models.ForeignKey(Profile, on_delete=models.CASCADE)
    order_date = models.DateTimeField()
    amount = models.DecimalField(max_digits=10, decimal_places=2)

Admettons maintenant que nous souhaitions interroger les données de Order sur la base du username de CustomUser.

Filtrage des relations multiples :

# Rechercher les commandes dans Order où le username de CustomUser est 'jesse'
orders_for_user = Order.objects.filter(profile__user__username='jesse')

Ici, nous pouvons accéder aux champs de CustomUser en traversant plusieurs niveaux de relation avec profile__user__username. C'est ainsi que nous mettons en œuvre le filtrage via __ à travers la relation Order → Profile → CustomUser.

Résumé

__ est utilisé pour référencer des champs en suivant les relations entre modèles.
Il est possible de définir diverses conditions de requête pour filtrer les données.
On peut relier des champs de relations multiples pour traiter facilement des requêtes complexes.

Maintenant que vous comprenez le rôle et l'utilisation de __, vous serez en mesure d'écrire des requêtes plus puissantes dans Django ORM. En gardant à l'esprit la structure relationnelle de la base de données et en utilisant ce symbole de manière appropriée, vous pourrez traiter efficacement les données et gérer des relations complexes facilement.