Résumer les données de MongoDB

Introduction

Dans ce laboratoire, vous allez apprendre à effectuer des opérations d'agrégation de base dans MongoDB, notamment le calcul de totaux, la recherche des valeurs minimales et maximales, le comptage des documents, le calcul de moyennes et la génération de rapports. Le laboratoire présente des exemples pratiques utilisant une collection d'échantillons de livres, démontrant le pouvoir du cadre d'agrégation de MongoDB pour extraire des informations significatives à partir de vos données.

Le laboratoire vous guide à travers des instructions étape par étape, en commençant par le calcul de valeurs totales, telles que la valeur totale des livres et la quantité totale. Vous apprendrez ensuite à trouver les prix minimum et maximum des livres, compter le nombre de documents et calculer la moyenne des prix des livres. Enfin, vous explorerez la génération de rapports pour résumer les données de votre collection.

Skills Graph

Calculer les totaux

Dans cette étape, vous allez apprendre à calculer des valeurs totales à l'aide du cadre d'agrégation de MongoDB. Nous utiliserons une collection d'échantillons de livres pour démontrer comment additionner des champs numériques.

Tout d'abord, lançons le shell MongoDB et créons une collection d'échantillons de livres :

mongosh

Maintenant, créons une collection de livres avec des prix :

use bookstore

db.books.insertMany([
    { titre: "Python Basics", prix: 29,99, quantité: 50 },
    { titre: "MongoDB Essentials", prix: 39,99, quantité: 30 },
    { titre: "Data Science Guide", prix: 45,50, quantité: 25 },
    { titre: "Web Development", prix: 34,75, quantité: 40 }
])

Pour calculer la valeur totale de tous les livres, nous utiliserons l'opérateur d'agrégation $sum :

db.books.aggregate([
  {
    $group: {
      _id: null,
      totalBookValue: { $sum: { $multiply: ["$prix", "$quantité"] } }
    }
  }
]);

Sortie exemple :

[
  {
    _id: null,
    totalBookValue: 5197,25
  }
]

Analysons ce que fait cette agrégation :

• $group regroupe tous les documents
• _id: null signifie que nous sommes en train d'agréguer toute la collection
• $multiply calcule la valeur totale de chaque livre (prix * quantité)
• $sum additionne toutes ces valeurs

Vous pouvez également calculer d'autres totaux, comme le nombre total de livres :

db.books.aggregate([
  {
    $group: {
      _id: null,
      totalQuantity: { $sum: "$quantité" }
    }
  }
]);

Sortie exemple :

[
  {
    _id: null,
    totalQuantity: 145
  }
]

Trouver les valeurs minimales et maximales

Dans cette étape, vous allez apprendre à trouver les valeurs minimales et maximales à l'aide du cadre d'agrégation de MongoDB. Nous allons continuer à utiliser notre collection de librairie de l'étape précédente.

Vérifions d'abord notre collection existante :

use bookstore
db.books.find()

Pour trouver les prix minimum et maximum des livres, nous utiliserons les opérateurs d'agrégation $min et $max :

db.books.aggregate([
  {
    $group: {
      _id: null,
      lowestPrice: { $min: "$prix" },
      highestPrice: { $max: "$prix" }
    }
  }
]);

Sortie exemple :

[
  {
    _id: null,
    lowestPrice: 29,99,
    highestPrice: 45,50
  }
]

Nous pouvons également trouver les quantités minimales et maximales :

db.books.aggregate([
  {
    $group: {
      _id: null,
      lowestQuantity: { $min: "$quantité" },
      highestQuantity: { $max: "$quantité" }
    }
  }
]);

Sortie exemple :

[
  {
    _id: null,
    lowestQuantity: 25,
    highestQuantity: 50
  }
]

Pour des analyses plus détaillées, nous pouvons trouver le livre avec le prix le plus bas et le plus élevé :

db.books.aggregate([
  {
    $sort: { prix: 1 }
  },
  {
    $limit: 1
  },
  {
    $project: {
      titre: 1,
      prix: 1
    }
  }
]);

Sortie exemple :

[
  {
    _id: ObjectId("..."),
    titre: "Python Basics",
    prix: 29,99
  }
]

Compter les documents

Dans cette étape, vous allez apprendre différentes méthodes pour compter les documents dans MongoDB en utilisant diverses techniques. Nous allons continuer à travailler avec notre collection de librairie des étapes précédentes.

Tout d'abord, vérifions notre collection existante :

use bookstore
db.books.find()

Il existe plusieurs façons de compter les documents dans MongoDB. Explorons-les :

1. Méthode de comptage de base :

db.books.countDocuments();

Sortie exemple :

4

2. Compter les documents avec un filtre :

db.books.countDocuments({ prix: { $gt: 35 } });

Cela compte les livres dont le prix est supérieur à 35.

Sortie exemple :

2

3. Utiliser le cadre d'agrégation pour compter :

db.books.aggregate([
  {
    $match: { quantité: { $gte: 30 } }
  },
  {
    $count: "booksWithHighQuantity"
  }
]);

Cela compte les livres dont la quantité est supérieure ou égale à 30.

Sortie exemple :

[
  {
    booksWithHighQuantity: 3
  }
]

4. Compter les valeurs uniques :

db.books.aggregate([
  {
    $group: {
      _id: "$titre",
      count: { $sum: 1 }
    }
  }
]);

Cela montre combien de fois chaque titre de livre apparaît.

Sortie exemple :

[
  {
    _id: "Python Basics",
    count: 1
  },
...
]

Calculer les moyennes

Dans cette étape, vous allez apprendre à calculer des valeurs moyennes à l'aide du cadre d'agrégation de MongoDB. Nous allons continuer à travailler avec notre collection de librairie des étapes précédentes.

Tout d'abord, vérifions notre collection existante :

use bookstore
db.books.find()

1. Calculer la moyenne du prix des livres :

db.books.aggregate([
  {
    $group: {
      _id: null,
      averagePrice: { $avg: "$prix" }
    }
  }
]);

Sortie exemple :

[
  {
    _id: null,
    averagePrice: 37,56
  }
]

2. Calculer la moyenne de la quantité avec arrondi :

db.books.aggregate([
  {
    $group: {
      _id: null,
      averageQuantity: { $avg: "$quantité" }
    }
  },
  {
    $project: {
      averageQuantity: { $round: ["$averageQuantity", 2] }
    }
  }
]);

Sortie exemple :

[
  {
    _id: null,
    averageQuantity: 36,25
  }
]

3. Moyenne du prix par regroupement conditionnel :

db.books.aggregate([
  {
    $group: {
      _id: {
        priceCategory: {
          $switch: {
            branches: [
              { case: { $lt: ["$prix", 35] }, then: "Budget" },
              { case: { $gte: ["$prix", 35] }, then: "Premium" }
            ]
          }
        }
      },
      averagePrice: { $avg: "$prix" }
    }
  }
]);

Sortie exemple :

[
  {
    _id: { priceCategory: "Budget" },
    averagePrice: 32,37
  },
  {
    _id: { priceCategory: "Premium" },
    averagePrice: 42,75
  }
]

Générer des rapports

Dans cette étape finale, vous allez apprendre à générer des rapports plus complexes à l'aide du cadre d'agrégation de MongoDB. Nous allons combiner plusieurs étapes d'agrégation pour créer des rapports instructifs à partir de notre collection de librairie.

Tout d'abord, vérifions notre collection existante :

use bookstore
db.books.find()

1. Rapport d'inventaire de livres complet :

db.books.aggregate([
  {
    $project: {
      titre: 1,
      totalValue: { $multiply: ["$prix", "$quantité"] },
      inventoryStatus: {
        $switch: {
          branches: [
            { case: { $lt: ["$quantité", 30] }, then: "Stock bas" },
            { case: { $gte: ["$quantité", 30] }, then: "En stock" }
          ]
        }
      }
    }
  },
  {
    $sort: { totalValue: -1 }
  }
]);

Sortie exemple :

[
  {
    _id: ObjectId("..."),
    titre: "Python Basics",
    totalValue: 1499,50,
    inventoryStatus: "En stock"
  },
...
]

2. Rapport de répartition des plages de prix :

db.books.aggregate([
  {
    $bucket: {
      groupBy: "$prix",
      boundaries: [0, 35, 45, 100],
      default: "Autre",
      output: {
        count: { $sum: 1 },
        titres: { $push: "$titre" }
      }
    }
  }
]);

Sortie exemple :

[
  {
    _id: 0,
    count: 2,
    titres: ["Python Basics", "Web Development"]
  },
  {
    _id: 35,
    count: 1,
    titres: ["MongoDB Essentials"]
  },
...
]

3. Rapport détaillé de performance commerciale :

db.books.aggregate([
  {
    $group: {
      _id: {
        priceCategory: {
          $switch: {
            branches: [
              { case: { $lt: ["$prix", 35] }, then: "Budget" },
              { case: { $gte: ["$prix", 35] }, then: "Premium" }
            ]
          }
        }
      },
      totalBooks: { $sum: 1 },
      totalQuantity: { $sum: "$quantité" },
      totalValue: { $sum: { $multiply: ["$prix", "$quantité"] } },
      avgPrice: { $avg: "$prix" }
    }
  },
  {
    $project: {
      _id: 0,
      priceCategory: "$_id.priceCategory",
      totalBooks: 1,
      totalQuantity: 1,
      totalValue: { $round: ["$totalValue", 2] },
      avgPrice: { $round: ["$avgPrice", 2] }
    }
  }
]);

Sortie exemple :

[
  {
    priceCategory: "Budget",
    totalBooks: 2,
    totalQuantity: 90,
    totalValue: 2984,50,
    avgPrice: 32,37
  },
  {
    priceCategory: "Premium",
    totalBooks: 2,
    totalQuantity: 55,
    totalValue: 2212,75,
    avgPrice: 42,75
  }
]

Sommaire

Dans ce laboratoire, vous allez apprendre à calculer des totaux, à trouver les valeurs minimales et maximales, à compter les documents, à calculer des moyennes et à générer des rapports à l'aide du cadre d'agrégation de MongoDB. Tout d'abord, vous calculerez la valeur totale de tous les livres dans une collection d'échantillon de livres en utilisant l'opérateur d'agrégation $sum. Vous allez également apprendre à calculer le nombre total de livres. Ensuite, vous trouverez les prix minimum et maximum des livres en utilisant les opérateurs d'agrégation $min et $max. Vous apprendrez ensuite à compter le nombre de documents dans la collection et à calculer le prix moyen des livres.