Introduction
Dans ce laboratoire, vous apprendrez à effectuer des opérations d'agrégation de base dans MongoDB. Ces opérations vous permettent de traiter des enregistrements de données et de retourner des résultats calculés. Vous apprendrez à calculer des totaux, à trouver les valeurs minimales et maximales, à compter des documents et à calculer des moyennes. Le laboratoire utilise un exemple de collection bookstore pour démontrer la puissance du framework d'agrégation de MongoDB pour extraire des informations significatives de vos données.
Connexion et peuplement des données
Avant de pouvoir résumer les données, nous devons nous connecter au serveur MongoDB et insérer des données d'exemple. Dans cette étape, vous allez démarrer le MongoDB Shell, créer une base de données et peupler une collection avec des informations sur les livres.
Tout d'abord, ouvrez votre terminal et démarrez le MongoDB Shell (mongosh) :
mongosh
Vous êtes maintenant dans le MongoDB Shell, qui vous permet d'interagir avec vos bases de données. Passons à une nouvelle base de données nommée bookstore. Si la base de données n'existe pas, MongoDB la créera pour vous lorsque vous y stockerez des données pour la première fois.
use bookstore
Ensuite, nous allons insérer plusieurs documents de livres dans une collection nommée books en utilisant la méthode insertMany(). Chaque document est un objet JSON contenant un title, un price et une quantity.
db.books.insertMany([
{ title: "Python Basics", price: 29.99, quantity: 50 },
{ title: "MongoDB Essentials", price: 39.99, quantity: 30 },
{ title: "Data Science Guide", price: 45.5, quantity: 25 },
{ title: "Web Development", price: 34.75, quantity: 40 }
]);
Vous devriez voir une sortie confirmant que les documents ont été insérés avec succès.
Pour vérifier que les données ont été ajoutées, vous pouvez utiliser la méthode find() pour récupérer et afficher tous les documents de la collection books.
db.books.find();
La sortie listera les quatre documents que vous venez d'insérer, chacun avec un _id unique attribué par MongoDB.
[
{
_id: ObjectId("..."),
title: 'Python Basics',
price: 29.99,
quantity: 50
},
{
_id: ObjectId("..."),
title: 'MongoDB Essentials',
price: 39.99,
quantity: 30
},
{
_id: ObjectId("..."),
title: 'Data Science Guide',
price: 45.5,
quantity: 25
},
{
_id: ObjectId("..."),
title: 'Web Development',
price: 34.75,
quantity: 40
}
]
Maintenant que notre collection est configurée, nous pouvons procéder à l'exécution des opérations d'agrégation.
Calculer les totaux
Dans cette étape, vous apprendrez à calculer des valeurs totales en utilisant le framework d'agrégation de MongoDB. Les pipelines d'agrégation traitent les données à travers une série d'étapes (stages). Nous utiliserons l'étape $group pour regrouper les documents et l'opérateur $sum pour effectuer des calculs.
Commençons par calculer le nombre total de livres en stock pour tous les titres. Nous allons regrouper tous les documents en un seul groupe et additionner leurs champs quantity.
db.books.aggregate([
{
$group: {
_id: null,
totalQuantity: { $sum: "$quantity" }
}
}
]);
Voici une explication de la commande :
db.books.aggregate([...]): Lance un pipeline d'agrégation sur la collectionbooks.$group: L'étape qui regroupe les documents d'entrée._id: null: Spécifie que tous les documents de la collection doivent être regroupés en un seul document de sortie.totalQuantity: { $sum: "$quantity" }: Définit un nouveau champtotalQuantity. L'opérateur$sumcalcule la somme du champquantity(précédé de$) pour tous les documents du groupe.
La sortie attendue est :
[{ "_id": null, "totalQuantity": 145 }]
Ensuite, calculons la valeur totale de l'inventaire pour tous les livres combinés. Cela nécessite de multiplier le price par la quantity pour chaque livre, puis de sommer les résultats.
db.books.aggregate([
{
$group: {
_id: null,
totalBookValue: { $sum: { $multiply: ["$price", "$quantity"] } }
}
}
]);
Dans ce pipeline :
$multiply: ["$price", "$quantity"]: Cette expression multiplie les champspriceetquantitypour chaque document.$sum: Cet opérateur additionne ensuite les résultats de la multiplication pour tous les documents.
La sortie attendue est :
[{ "_id": null, "totalBookValue": 5226.7 }]
Trouver les valeurs minimales et maximales
Trouver les valeurs minimales et maximales dans un ensemble de données est une tâche d'analyse courante. Dans cette étape, vous utiliserez les opérateurs d'agrégation $min et $max pour trouver les livres les moins chers et les plus chers de notre collection.
Comme $sum, les opérateurs $min et $max sont utilisés dans l'étape $group. Créons un seul pipeline d'agrégation pour trouver à la fois les prix des livres les plus bas et les plus élevés.
db.books.aggregate([
{
$group: {
_id: null,
lowestPrice: { $min: "$price" },
highestPrice: { $max: "$price" }
}
}
]);
Ce pipeline fonctionne comme suit :
_id: null: Regroupe tous les documents ensemble.lowestPrice: { $min: "$price" }: Crée un champlowestPriceet lui attribue la valeur minimale du champpricesur tous les documents.highestPrice: { $max: "$price" }: Crée un champhighestPriceet lui attribue la valeur maximale du champprice.
La sortie attendue montrera les prix minimum et maximum trouvés dans la collection :
[{ "_id": null, "lowestPrice": 29.99, "highestPrice": 45.5 }]
Vous pouvez appliquer la même logique à d'autres champs numériques. Par exemple, pour trouver les quantités minimales et maximales en stock, vous utiliseriez $min et $max sur le champ quantity.
db.books.aggregate([
{
$group: {
_id: null,
lowestQuantity: { $min: "$quantity" },
highestQuantity: { $max: "$quantity" }
}
}
]);
La sortie attendue pour cette requête est :
[{ "_id": null, "lowestQuantity": 25, "highestQuantity": 50 }]
Compter les documents et calculer les moyennes
Dans cette étape, vous apprendrez deux techniques de résumé supplémentaires utiles : le comptage de documents et le calcul de moyennes. Nous explorerons à la fois une méthode de comptage simple et le framework d'agrégation pour des scénarios plus complexes.
Tout d'abord, comptons le nombre total de documents dans notre collection books. La méthode countDocuments() est le moyen le plus simple de le faire.
db.books.countDocuments();
La sortie sera un seul nombre :
4
Vous pouvez également fournir un filtre de requête à countDocuments() pour ne compter que les documents qui correspondent à des critères spécifiques. Par exemple, comptons combien de livres ont un prix supérieur à 35 $.
db.books.countDocuments({ price: { $gt: 35 } });
L'opérateur $gt signifie "greater than" (supérieur à). La sortie sera :
2
Ensuite, calculons le prix moyen des livres en utilisant le framework d'agrégation. L'opérateur $avg, utilisé dans une étape $group, calcule la moyenne d'un champ numérique.
db.books.aggregate([
{
$group: {
_id: null,
averagePrice: { $avg: "$price" }
}
}
]);
Ce pipeline regroupe tous les documents et calcule la moyenne du champ price. La sortie sera :
[{ "_id": null, "averagePrice": 37.56 }]
Le framework d'agrégation offre un moyen puissant et flexible d'effectuer des calculs tels que le comptage et la moyenne, en particulier lorsqu'il est combiné à d'autres étapes pour gérer une logique plus complexe.
Générer un rapport de synthèse
Dans cette dernière étape, vous combinerez plusieurs étapes d'agrégation pour générer un rapport récapitulatif plus complexe. Cela démontre comment vous pouvez enchaîner des opérateurs pour créer des vues pertinentes de vos données. Nous allons créer un rapport qui catégorise les livres en niveaux de prix "Budget" et "Premium" et calcule les statistiques récapitulatives pour chacun.
Notre objectif est de regrouper les livres en fonction de leur prix, puis de calculer le nombre de titres, la quantité totale, la valeur totale et le prix moyen pour chaque groupe.
Exécutez le pipeline d'agrégation suivant :
db.books.aggregate([
{
$group: {
_id: {
$cond: {
if: { $lt: ["$price", 35] },
then: "Budget",
else: "Premium"
}
},
totalBooks: { $sum: 1 },
totalQuantity: { $sum: "$quantity" },
totalValue: { $sum: { $multiply: ["$price", "$quantity"] } },
avgPrice: { $avg: "$price" }
}
}
]);
Décomposons ce pipeline puissant :
$group: Cette étape est le cœur de notre rapport._id: { $cond: ... }: Au lieu denull, nous utilisons l'opérateur$cond(conditionnel) pour déterminer dynamiquement l'identifiant du groupe. Si lepriced'un livre est inférieur ($lt) à 35, il est assigné au groupe "Budget" ; sinon, il est "Premium".totalBooks: { $sum: 1 }: C'est une technique courante pour compter les documents au sein d'un groupe. Pour chaque document, elle ajoute1au total.totalQuantity,totalValue,avgPrice: Ce sont les mêmes accumulateurs que ceux que vous avez appris dans les étapes précédentes, mais ils opèrent maintenant au sein de chaque catégorie de prix.
La sortie fournit un résumé clair pour chaque catégorie. Notez que l'ordre des documents peut varier.
[
{
"_id": "Premium",
"totalBooks": 2,
"totalQuantity": 55,
"totalValue": 2212.75,
"avgPrice": 42.745
},
{
"_id": "Budget",
"totalBooks": 2,
"totalQuantity": 90,
"totalValue": 2984.5,
"avgPrice": 32.37
}
]
Cet exemple montre comment le framework d'agrégation peut être utilisé pour transformer des données brutes en rapports structurés et significatifs directement dans la base de données.
Résumé
Dans ce laboratoire, vous avez appris les bases de l'agrégation de données dans MongoDB. Vous avez commencé par vous connecter à une base de données et peupler une collection avec des données d'exemple. Vous avez ensuite utilisé le framework d'agrégation pour effectuer plusieurs tâches de résumé courantes. Vous avez appris à utiliser l'étape $group avec des opérateurs tels que $sum pour calculer des totaux, $min et $max pour trouver des valeurs limites, et $avg pour calculer des moyennes. Vous vous êtes également exercé à utiliser countDocuments() pour des comptages simples et avez vu comment construire un rapport récapitulatif multifacette en combinant plusieurs opérateurs et étapes. Ces compétences sont essentielles pour analyser les données et en tirer des informations précieuses de vos collections MongoDB.
