Dans un post précédent, nous avons présenté comment manipuler des données à l'aide de l'ORM de Django, c'est-à-dire les opérations CRUD (Créer, Lire, Mettre à jour, Supprimer). Cette fois-ci, nous allons analyser de manière plus approfondie ce qu'est exactement le objects gestionnaire, comment il est structuré et ce qu'il peut faire. Le objects est un concept essentiel à comprendre pour saisir correctement l'ORM de Django.

1. Qu'est-ce que le gestionnaire objects ?

Ce qui apparaît le plus souvent dans la structure de base d'un modèle Django, c'est le gestionnaire objects. Le objects est appelé gestionnaire de modèle (Manager) de Django et est responsable de la recherche ou de la manipulation des enregistrements de la base de données. En d'autres termes, le gestionnaire objects joue le rôle de pont entre la classe de modèle et la base de données.

La propriété de base de la classe de modèle, objects, est une instance de la classe Manager fournie par Django. À travers cette instance, nous communiquons avec la base de données pour effectuer des opérations telles que la création, la recherche, la modification et la suppression de données. Par exemple, nous pouvons accéder aux données en utilisant des méthodes telles que Post.objects.all() ou Post.objects.create().

2. Rôle de la classe Manager

La classe Manager est l'interface de base fournie aux modèles Django pour interagir avec la base de données. Grâce à elle, nous pouvons effectuer diverses requêtes. Par défaut, Django génère automatiquement un Manager nommé objects pour chaque modèle, et ce Manager est utilisé pour traiter la plupart des opérations CRUD.

Vous savez probablement déjà comment les opérations CRUD sont mises en œuvre via objects, ou vous avez peut-être déjà de l'expérience avec cela. Le code d'exemple a été abordé dans un article précédent, donc nous l'omettrons ici.

3. Créer un gestionnaire personnalisé

Bien que le gestionnaire objects fourni par défaut soit très utile, il y a parfois besoin de réutiliser une logique de requête spécifique ou d'effectuer des recherches plus complexes. Dans ces cas, nous pouvons créer un gestionnaire personnalisé pour ajouter la fonctionnalité souhaitée.

3.1 Définir une classe de gestionnaire personnalisée

Par exemple, nous allons créer un gestionnaire personnalisé qui filtre uniquement les publications publiées.

from django.db import models

class PublishedManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(status='published')

class Post(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    status = models.CharField(max_length=10, choices=[('draft', 'Brouillon'), ('published', 'Publiée')])
    publish_date = models.DateTimeField(auto_now_add=True)

    # Ajout d'un gestionnaire personnalisé en plus du gestionnaire objects par défaut
    published = PublishedManager()

Dans l'exemple ci-dessus, nous avons défini un gestionnaire personnalisé appelé PublishedManager et l'avons ajouté au modèle Post. Ce PublishedManager filtre et renvoie uniquement les publications dont le statut est 'published'. Maintenant, en appelant Post.published.all(), nous pouvons obtenir uniquement les publications publiées.

3.2 Utilisation du gestionnaire personnalisé

• Réduction du code dupliqué : Au lieu d'ajouter des conditions de filtrage à chaque fois, utiliser un gestionnaire personnalisé permet de réduire la répétition du code.
• Encapsulation de la logique de requête spécialisée : Vous pouvez personnaliser la logique de requête selon des besoins métiers spécifiques et gérer cela de manière ordonnée au sein du modèle.

4. Différentes opérations réalisables avec le gestionnaire objects

Le gestionnaire objects de Django prend en charge non seulement les fonctionnalités CRUD de base, mais aussi diverses autres opérations sur la base de données.

4.1 Filtrage des données

• filter() : Récupère plusieurs objets correspondant aux conditions spécifiées.

  published_posts = Post.objects.filter(status='published')

• exclude() : Récupère des objets ne correspondant pas à certaines conditions.

  draft_posts = Post.objects.exclude(status='published')

4.2 Tri et slicing

• Tri : Vous pouvez trier les données en utilisant la méthode order_by().

  recent_posts = Post.objects.all().order_by('-publish_date')

• Slicing : Comme pour les listes Python, vous pouvez également faire du slicing sur les querysets pour obtenir des données dans une plage spécifique.

  first_three_posts = Post.objects.all()[:3]

4.3 Utilisation de fonctions d'agrégation

Le gestionnaire objects offre également des fonctions d'agrégation. Par exemple, si vous souhaitez connaître le nombre de publications, vous pouvez utiliser la méthode count().

post_count = Post.objects.count()

De plus, vous pouvez utiliser la méthode aggregate() pour réaliser des opérations d'agrégation telles que la moyenne et la somme.

from django.db.models import Avg
average_length = Post.objects.aggregate(Avg('content_length'))

5. Principe de fonctionnement du gestionnaire objects

Le gestionnaire objects crée en interne un objet appelé QuerySet. Un queryset est un ensemble de requêtes pour extraire des données de la base de données. Chaque fois que des méthodes comme objects.all() ou objects.filter() sont appelées, Django crée un queryset et, si nécessaire, envoie cette requête à la base de données pour récupérer les résultats.

Les querysets utilisent l'évaluation paresseuse (lazy evaluation). Cela signifie que lorsque le queryset est créé, Django n'accède pas immédiatement à la base de données, mais exécute la requête de la base de données au moment où les données sont réellement nécessaires. Cela permet d'éviter l'exécution de requêtes inutiles et d'assurer un traitement efficace des données.

Conclusion

Le gestionnaire objects de Django simplifie l'interaction avec la base de données et permet de manipuler les données plus facilement. En plus des fonctionnalités CRUD de base, vous pouvez définir des gestionnaires personnalisés pour réutiliser une logique de requête spécifique ou gérer des tâches plus complexes en toute simplicité. De plus, grâce à des caractéristiques telles que l'évaluation paresseuse des querysets, un traitement efficace des données est également possible.

Une compréhension approfondie du gestionnaire objects de Django ORM vous permettra de manipuler la base de données de manière plus efficace et de réduire la duplication du code tout en rendant votre code plus propre. À l'avenir, essayez d'augmenter l'utilisation des gestionnaires de modèles et d'intégrer des gestionnaires personnalisés lorsque cela est nécessaire. Cela rendra le traitement des données complexes dans votre application web beaucoup plus facile et flexible.

Dans le prochain épisode, nous aborderons en détail les QuerySets et la récupération de données. L'un des avantages de l'ORM est que "vous n'avez pas besoin de connaître SQL", et pour bien profiter de cet avantage, le contenu du prochain épisode sera très important. Restez à l'écoute pour le prochain épisode.