Le pipeline d’agrégation est le moyen recommandé pour exécuter des requêtes complexes dans MongoDB. Si vous avez utilisé MapReduce de MongoDB, il est préférable de passer au pipeline d’agrégation pour des calculs plus efficaces.
Qu’est-ce que l’agrégation dans MongoDB et comment fonctionne-t-elle ?
Le pipeline d’agrégation est un processus en plusieurs étapes permettant d’exécuter des requêtes avancées dans MongoDB. Il traite les données à travers différentes étapes appelées pipeline. Vous pouvez utiliser les résultats générés à un niveau comme modèle d’opération à un autre niveau.
Par exemple, vous pouvez transmettre le résultat d’une opération de correspondance à un autre niveau pour qu’il soit trié dans cet ordre jusqu’à ce que vous obteniez le résultat souhaité.
Chaque étape d’un pipeline d’agrégation comporte un opérateur MongoDB et génère un ou plusieurs documents transformés. En fonction de votre requête, un niveau peut apparaître plusieurs fois dans le pipeline. Par exemple, vous pouvez avoir besoin d’utiliser l’opérateur $count ou $sort
Les étapes du pipeline d’agrégation
Le pipeline d’agrégation fait passer les données par plusieurs étapes au cours d’une seule requête. Il y a plusieurs étapes et vous pouvez trouver leurs détails dans la documentation de MongoDB.
Nous allons définir ci-dessous quelques-unes des étapes les plus couramment utilisées.
L’étape $match
Cette étape permet de définir des conditions de filtrage spécifiques avant de lancer les autres étapes d’agrégation. Vous pouvez l’utiliser pour sélectionner les données correspondantes que vous souhaitez inclure dans le pipeline d’agrégation.
L’étape $group
L’étape du groupe sépare les données en différents groupes sur la base de critères spécifiques en utilisant des paires clé-valeur. Chaque groupe représente une clé dans le document de sortie.
Prenons l’exemple suivant vente données de l’échantillon :
En utilisant le pipeline d’agrégation, vous pouvez calculer le nombre total de ventes et les meilleures ventes pour chaque section de produit :
{
$group: {
_id: $Section,
total_sales_count: {$sum : $Sold},
top_sales: {$max: $Amount},
}
}
Les _id : $Section regroupe le document de sortie en fonction des sections. En spécifiant la paire top_sales_count et top_sales MongoDB crée de nouvelles clés en fonction de l’opération définie par l’agrégateur. $sum, $min, $maxou $avg.
L’étape $skip
Vous pouvez utiliser l’option $skip Cette étape permet d’omettre un nombre spécifié de documents dans le résultat. Elle vient généralement après l’étape du groupe. Par exemple, si vous attendez deux documents en sortie mais que vous en omettez un, l’agrégation ne produira que le deuxième document.
Pour ajouter une étape de saut, insérez l’élément $skip dans le pipeline d’agrégation :
...,
{
$skip: 1
},
L’étape $sort
L’étape de tri permet de classer les données par ordre croissant ou décroissant. Par exemple, nous pouvons trier les données de l’exemple de requête précédent par ordre décroissant pour déterminer quelle section a les ventes les plus élevées.
Ajouter le $sort opérateur de la requête précédente :
...,
{
$sort: {top_sales: -1}
},
L’étape $limit
L’opération limit permet de réduire le nombre de documents de sortie que le pipeline d’agrégation doit afficher. Par exemple, utilisez l’étape $limit pour obtenir la section avec les ventes les plus élevées renvoyées par l’étape précédente :
...,
{
$sort: {top_sales: -1}
},{"$limit": 1}
L’opérateur ci-dessus ne renvoie que le premier document ; il s’agit de la section avec les ventes les plus élevées, puisqu’elle apparaît en haut de la sortie triée.
L’étape $projet
Le $projet vous permet de façonner le document de sortie comme vous le souhaitez. En utilisant l’étape $projet vous pouvez spécifier le champ à inclure dans la sortie et personnaliser son nom de clé.
Par exemple, un exemple de sortie sans l’opérateur $projet ressemble à ceci :
Voyons ce que cela donne avec l’option $projet étape. Pour ajouter l’étape $projet au pipeline :
...,{
"$project": {
"_id": 0,
"Section": "$_id",
"TotalSold": "$total_sales_count",
"TopSale": "$top_sales",
}
}
Étant donné que nous avons précédemment regroupé les données sur la base des sections de produits, ce qui précède inclut chaque section de produit dans le document de sortie. Il garantit également que le nombre de ventes agrégées et les ventes les plus importantes figurent dans le document de sortie en tant que Total des ventes et TopSale.
Le résultat final est beaucoup plus propre que le précédent :
L’étape $unwind
La $unwind stage décompose un tableau à l’intérieur d’un document en documents individuels. Prenons l’exemple suivant Commandes par exemple :
Utiliser la fonction $unwind étape de déconstruction de la articles avant d’appliquer d’autres étapes d’agrégation. Par exemple, en déroulant le tableau éléments Ce tableau a du sens si l’on veut calculer le revenu total pour chaque produit :
db.Orders.aggregate(
(
{
"$unwind": "$items"
},
{
"$group": {
"_id": "$items.product",
"total_revenue": { "$sum": { "$multiply": ("$items.quantity", "$items.price") } }
}
},
{
"$sort": { "total_revenue": -1 }
}, {
"$project": {
"_id": 0,
"Product": "$_id",
"TotalRevenue": "$total_revenue",
}
}
))
Voici le résultat de la requête d’agrégation ci-dessus :
Comment créer un pipeline d’agrégation dans MongoDB
Bien que le pipeline d’agrégation comprenne plusieurs opérations, les étapes présentées précédemment vous donnent une idée de la façon de les appliquer dans le pipeline, y compris la requête de base pour chacune d’entre elles.
En utilisant l’étape précédente ventes Si l’on considère l’échantillon de données de la base de données, on peut regrouper certaines des étapes mentionnées ci-dessus pour obtenir une vue d’ensemble du pipeline d’agrégation :
db.sales.aggregate(( {
"$match": {
"Sold": { "$gte": 5 }
}
},
{
"$group": {
"_id": "$Section",
"total_sales_count": { "$sum": "$Sold" },
"top_sales": { "$max": "$Amount" },
}
},
{
"$sort": { "top_sales": -1 }
},
{"$skip": 0},
{
"$project": {
"_id": 0,
"Section": "$_id",
"TotalSold": "$total_sales_count",
"TopSale": "$top_sales",
}
}
))
Le résultat final ressemble à quelque chose que vous avez déjà vu :
Pipeline d’agrégation vs. MapReduce
Jusqu’à sa suppression à partir de MongoDB 5.0, la manière conventionnelle d’agréger des données dans MongoDB était MapReduce. Bien que MapReduce ait des applications plus larges que MongoDB, il est moins efficace que le pipeline d’agrégation, car il nécessite des scripts tiers pour écrire les fonctions map et reduce séparément.
Le pipeline d’agrégation, quant à lui, est spécifique à MongoDB. Mais il offre un moyen plus propre et plus efficace d’exécuter des requêtes complexes. Outre la simplicité et l’évolutivité des requêtes, les différentes étapes du pipeline rendent le résultat plus personnalisable.
Il existe de nombreuses autres différences entre le pipeline d’agrégation et MapReduce. Vous les verrez lorsque vous passerez de MapReduce au pipeline d’agrégation.
Rendre les requêtes Big Data efficaces dans MongoDB
Votre requête doit être aussi efficace que possible si vous souhaitez effectuer des calculs approfondis sur des données complexes dans MongoDB. Le pipeline d’agrégation est idéal pour les requêtes avancées. Plutôt que de manipuler les données dans des opérations séparées, ce qui réduit souvent les performances, l’agrégation vous permet de les regrouper dans un seul pipeline performant et de les exécuter une seule fois.
Bien que le pipeline d’agrégation soit plus efficace que MapReduce, vous pouvez rendre l’agrégation plus rapide et plus efficace en indexant vos données. Cela limite la quantité de données que MongoDB doit analyser à chaque étape de l’agrégation.