Comment utiliser le pipeline d'agrégation dans MongoDB

Le pipeline d'agrégation est le moyen recommandé pour exécuter des requêtes complexes dans MongoDB. Si vous utilisez MapReduce de MongoDB, vous feriez mieux de passer au pipeline d'agrégation pour des calculs plus efficaces.

Qu'est-ce que l'agrégation dans MongoDB et comment ça marche?

Le pipeline d'agrégation est un processus en plusieurs étapes permettant d'exécuter des requêtes dans MongoDB. Il traite les données à travers différentes étapes appelées pipeline. Vous pouvez utiliser les résultats générés à partir d'un niveau comme modèle d'opération dans un autre.

Par exemple, vous pouvez transmettre le résultat d'une opération de correspondance à une autre étape pour le trier 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 devrez peut-être utiliser le

compte $ ou $trier l’opérateur effectue plusieurs étapes dans le pipeline d’agrégation.

Les étapes du pipeline d’agrégation

Le pipeline d'agrégation transmet les données à travers plusieurs étapes en une seule requête. Il y a plusieurs étapes et vous pouvez retrouver leurs détails dans la Documentation MongoDB.

Définissons ci-dessous quelques-uns des plus couramment utilisés.

L'étape $ match

Cette étape vous aide à définir des conditions de filtrage spécifiques avant de démarrer 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.

La scène $group

L'étape de groupe sépare les données en différents groupes en fonction de critères spécifiques à l'aide de paires clé-valeur. Chaque groupe représente une clé dans le document de sortie.

Par exemple, considérons ce qui suit ventes exemples de données :

À l'aide du 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},
 }
}

Le _id: $Section pair regroupe le document de sortie en fonction des sections. En précisant le top_sales_count et meilleures ventes champs, MongoDB crée de nouvelles clés basées sur l'opération définie par l'agrégateur; cela peut être somme $, $min, $max, ou $moy..

L'étape $skip

Vous pouvez utiliser le $ sauter étape pour omettre un nombre spécifié de documents dans la sortie. Cela vient généralement après la phase de groupes. Par exemple, si vous attendez deux documents de sortie mais en ignorez un, l'agrégation ne produira que le deuxième document.

Pour ajouter une étape sautée, insérez le $ sauter opération dans le pipeline d’agrégation :

...,
{
 $skip: 1
 },

L'étape du tri $

L'étape de tri vous permet de classer les données par ordre décroissant ou croissant. Par exemple, nous pouvons trier davantage 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 $trier opérateur à la requête précédente :

...,
{
 $sort: {top_sales: -1}
 },

L'étape $limite

L'opération de limitation permet de réduire le nombre de documents de sortie que vous souhaitez que le pipeline d'agrégation affiche. Par exemple, utilisez le $limite opérateur pour obtenir la section avec les ventes les plus élevées renvoyée par l'étape précédente :

...,
{
 $sort: {top_sales: -1}
 },
{"$limit": 1}

Ce qui précède renvoie uniquement le premier document; il s'agit de la section avec les ventes les plus élevées, telle qu'elle apparaît en haut de la sortie triée.

L'étape $project

Le $projet stage vous permet de façonner le document de sortie à votre guise. En utilisant le $projet opérateur, vous pouvez spécifier le champ à inclure dans la sortie et personnaliser son nom de clé.

Par exemple, un exemple de sortie sans le $projet la scène ressemble à ceci :

Voyons à quoi ça ressemble avec le $projet scène. Pour ajouter le $projet au pipeline :

...,
{
 "$project": {
 "_id": 0,
 "Section": "$_id",
 "TotalSold": "$total_sales_count",
 "TopSale": "$top_sales",
 }
 }

Puisque nous avons précédemment regroupé les données en fonction des sections de produits, ce qui précède inclut chaque section de produit dans le document de sortie. Il garantit également que le décompte des ventes agrégées et les principales ventes figurent dans la sortie, comme TotalVendu et TopVente.

Le résultat final est beaucoup plus propre par rapport au précédent :

L'étape $détente

Le $se détendre L'étape décompose un tableau d'un document en documents individuels. Prenez ce qui suit Ordres des données, par exemple :

Utilisez le $se détendre étape pour déconstruire le articles tableau avant d’appliquer d’autres étapes d’agrégation. Par exemple, dérouler le articles array est logique si vous souhaitez calculer le chiffre d'affaires 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.

En utilisant le précédent ventes échantillon de données, regroupons certaines des étapes décrites ci-dessus en un seul morceau pour une vue plus large 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 vu précédemment :

Pipeline d’agrégation vs. CarteRéduire

Jusqu'à sa dépréciation à partir de MongoDB 5.0, la manière conventionnelle d'agréger des données dans MongoDB était via MapReduce. Bien que MapReduce a des applications plus larges au-delà de MongoDB, il est moins efficace que le pipeline d'agrégation, nécessitant des scripts tiers pour écrire la carte et réduire les fonctions séparément.

Le pipeline d'agrégation, en revanche, est spécifique à MongoDB uniquement. 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 étapes de pipeline présentées rendent la sortie plus personnalisable.

Il y en a bien d'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 la plus efficace possible si vous souhaitez exécuter 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 distinctes, ce qui réduit souvent les performances, l'agrégation vous permet de toutes 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 d'agrégation.