Transformer les données MongoDB

Introduction

Dans ce laboratoire (lab), vous apprendrez à transformer les données MongoDB à l'aide d'opérations d'agrégation de base. Le laboratoire couvre cinq étapes clés : la sélection des champs de sortie, le renommage des champs, le calcul de nouveaux champs, la mise en forme de la sortie et le filtrage des résultats. Grâce à ces étapes, vous aurez l'expérience pratique de la restructuration et de l'analyse des données stockées dans les collections MongoDB. Le laboratoire fournit un ensemble de données d'exemple sur des livres et montre comment utiliser le pipeline d'agrégation pour extraire, manipuler et présenter les données d'une manière plus significative.

Skills Graph

Sélectionner les champs de sortie

Dans cette étape, nous allons apprendre à utiliser le pipeline d'agrégation de MongoDB pour sélectionner et transformer les champs de sortie. L'agrégation est un moyen puissant de traiter et d'analyser les données dans MongoDB.

Tout d'abord, lançons le shell MongoDB :

mongosh

Maintenant, créons une collection d'exemple de livres avec laquelle travailler :

use bookstore

db.books.insertMany([
    {
        title: "MongoDB Basics",
        author: "Jane Smith",
        price: 29.99,
        pages: 250,
        categories: ["Database", "Programming"]
    },
    {
        title: "Python Deep Dive",
        author: "John Doe",
        price: 39.99,
        pages: 450,
        categories: ["Programming", "Python"]
    },
    {
        title: "Data Science Handbook",
        author: "Alice Johnson",
        price: 49.99,
        pages: 600,
        categories: ["Data Science", "Programming"]
    }
])

Maintenant, utilisons le pipeline d'agrégation pour sélectionner des champs de sortie spécifiques :

db.books.aggregate([
  {
    $project: {
      _id: 0,
      bookTitle: "$title",
      bookAuthor: "$author"
    }
  }
]);

Exemple de sortie :

[
  { bookTitle: 'MongoDB Basics', bookAuthor: 'Jane Smith' },
  { bookTitle: 'Python Deep Dive', bookAuthor: 'John Doe' },
  { bookTitle: 'Data Science Handbook', bookAuthor: 'Alice Johnson' }
]

Analysons ce que nous avons fait :

• $project est une étape d'agrégation qui redéfinit la structure des documents
• _id: 0 exclut l'ID de document MongoDB par défaut
• bookTitle: "$title" renomme le champ 'title' en 'bookTitle'
• bookAuthor: "$author" renomme le champ 'author' en 'bookAuthor'

Le symbole $ avant les noms de champs indique à MongoDB d'utiliser la valeur de ce champ.

Renommer les champs

Dans cette étape, nous allons explorer des techniques plus avancées de renommage de champs en utilisant le pipeline d'agrégation de MongoDB. Nous allons nous appuyer sur la collection de livres que nous avons créée à l'étape précédente.

Continuons dans le shell MongoDB :

mongosh

Tout d'abord, changeons de base de données pour notre base bookstore :

use bookstore

Maintenant, nous allons utiliser une étape $project plus complexe pour renommer et transformer plusieurs champs :

db.books.aggregate([
  {
    $project: {
      _id: 0,
      bookInfo: {
        name: "$title",
        writer: "$author",
        bookLength: "$pages",
        pricing: "$price"
      },
      genres: "$categories"
    }
  }
]);

Exemple de sortie :

[
  {
    bookInfo: {
      name: 'MongoDB Basics',
      writer: 'Jane Smith',
      bookLength: 250,
      pricing: 29.99
    },
    genres: [ 'Database', 'Programming' ]
  },
  //... autres documents de livres
]

Analysons la technique de renommage :

• Nous avons créé un objet imbriqué bookInfo avec des champs renommés
• name remplace title
• writer remplace author
• bookLength remplace pages
• pricing remplace price
• Nous avons également conservé categories sous le nom de genres

Vous pouvez également utiliser l'étape $rename pour un renommage de champs plus simple :

db.books.aggregate([
  {
    $rename: {
      title: "bookName",
      author: "bookWriter"
    }
  }
]);

Cette étape renomme directement les champs dans les documents originaux.

Calculer de nouveaux champs

Dans cette étape, nous allons apprendre à créer de nouveaux champs en effectuant des calculs à l'aide du pipeline d'agrégation de MongoDB. Nous continuerons à travailler avec notre base de données bookstore.

Commençons par lancer le shell MongoDB :

mongosh

Passons à la base de données bookstore :

use bookstore

Nous allons utiliser l'étape $addFields pour créer de nouveaux champs calculés :

db.books.aggregate([
  {
    $addFields: {
      totalValue: { $multiply: ["$price", 1.1] },
      discountedPrice: { $multiply: ["$price", 0.9] },
      pageCategories: {
        $concat: [
          { $toString: "$pages" },
          " page ",
          { $arrayElemAt: ["$categories", 0] }
        ]
      }
    }
  }
]);

Exemple de sortie :

[
  {
    _id: ObjectId("..."),
    title: "MongoDB Basics",
    author: "Jane Smith",
    price: 29.99,
    pages: 250,
    categories: ["Database", "Programming"],
    totalValue: 32.989,
    discountedPrice: 26.991,
    pageCategories: "250 page Database"
  },
  //... autres documents de livres
]

Analysons les calculs :

• totalValue : Multiplie le prix par 1,1 (marge de 10 %)
• discountedPrice : Multiplie le prix par 0,9 (remise de 10 %)
• pageCategories : Combine le nombre de pages avec la première catégorie à l'aide de $concat

Nous pouvons également effectuer des calculs plus complexes. Calculons une note de livre en fonction du nombre de pages :

db.books.aggregate([
  {
    $addFields: {
      bookRating: {
        $switch: {
          branches: [
            { case: { $lt: ["$pages", 300] }, then: "Short Book" },
            { case: { $lt: ["$pages", 500] }, then: "Medium Book" }
          ],
          default: "Long Book"
        }
      }
    }
  }
]);

Cet exemple utilise $switch pour catégoriser les livres en fonction de leur nombre de pages.

Mettre en forme la sortie

Dans cette étape, nous allons explorer diverses techniques pour mettre en forme et transformer la sortie en utilisant le pipeline d'agrégation de MongoDB. Nous continuerons à travailler avec notre base de données bookstore.

Commençons par lancer le shell MongoDB :

mongosh

Passons à la base de données bookstore :

use bookstore

Tout d'abord, utilisons $toUpper et $toLower pour mettre en forme les champs texte :

db.books.aggregate([
  {
    $project: {
      _id: 0,
      titleUpperCase: { $toUpper: "$title" },
      authorLowerCase: { $toLower: "$author" }
    }
  }
]);

Exemple de sortie :

[
  {
    titleUpperCase: 'MONGODB BASICS',
    authorLowerCase: 'jane smith'
  },
  //... autres documents de livres
]

Ensuite, mettons en forme les valeurs numériques à l'aide de $round et créons des chaînes de caractères de prix formatées :

db.books.aggregate([
  {
    $project: {
      _id: 0,
      title: 1,
      roundedPrice: { $round: ["$price", 1] },
      formattedPrice: {
        $concat: ["$", { $toString: { $round: ["$price", 2] } }]
      }
    }
  }
]);

Exemple de sortie :

[
  {
    title: 'MongoDB Basics',
    roundedPrice: 30,
    formattedPrice: '$29.99'
  },
  //... autres documents de livres
]

Nous pouvons également mettre en forme les tableaux et créer des représentations de chaînes de caractères complexes :

db.books.aggregate([
  {
    $project: {
      _id: 0,
      title: 1,
      categoriesSummary: {
        $reduce: {
          input: "$categories",
          initialValue: "",
          in: {
            $concat: [
              "$$value",
              { $cond: [{ $eq: ["$$value", ""], "", ", "] },
              "$$this"
            ]
          }
        }
      }
    }
  }
]);

Exemple de sortie :

[
  {
    title: 'MongoDB Basics',
    categoriesSummary: 'Database, Programming'
  },
  //... autres documents de livres
]

Ce dernier exemple utilise $reduce pour joindre les éléments d'un tableau en une chaîne de caractères séparée par des virgules.

Filtrer les résultats

Dans cette étape finale, nous allons explorer diverses techniques de filtrage en utilisant le pipeline d'agrégation de MongoDB. Nous continuerons à travailler avec notre base de données bookstore pour démontrer différentes façons de filtrer les résultats.

Commençons par lancer le shell MongoDB :

mongosh

Passons à la base de données bookstore :

use bookstore

Tout d'abord, filtrons les livres en utilisant des opérateurs de comparaison simples :

db.books.aggregate([
  {
    $match: {
      price: { $gt: 30 },
      pages: { $lt: 500 }
    }
  }
]);

Cette requête filtre les livres qui :

• Ont un prix supérieur à 30
• Ont moins de 500 pages

Exemple de sortie :

[
  {
    _id: ObjectId("..."),
    title: "Python Deep Dive",
    author: "John Doe",
    price: 39.99,
    pages: 450,
    categories: ["Programming", "Python"]
  }
]

Ensuite, utilisons un filtrage plus complexe avec des opérations sur les tableaux :

db.books.aggregate([
  {
    $match: {
      categories: { $in: ["Programming"] }
    }
  }
]);

Cette requête trouve tous les livres qui ont "Programming" dans leurs catégories.

Nous pouvons également combiner plusieurs techniques de filtrage :

db.books.aggregate([
  {
    $match: {
      $or: [{ pages: { $gt: 400 } }, { categories: { $in: ["Database"] } }]
    }
  },
  {
    $project: {
      title: 1,
      pages: 1,
      categories: 1
    }
  }
]);

Cette requête plus complexe :

• Trouve les livres ayant plus de 400 pages OU appartenant à la catégorie "Database"
• Projette seulement des champs spécifiques dans la sortie

Exemple de sortie :

[
  {
    _id: ObjectId("..."),
    title: "Data Science Handbook",
    pages: 600,
    categories: ["Data Science", "Programming"]
  },
  {
    _id: ObjectId("..."),
    title: "MongoDB Basics",
    pages: 250,
    categories: ["Database", "Programming"]
  }
]

Résumé

Dans ce laboratoire, vous avez appris à utiliser le pipeline d'agrégation de MongoDB pour sélectionner et transformer les champs de sortie. Vous avez commencé par créer une collection d'exemple de livres, puis utilisé l'étape $project pour sélectionner des champs spécifiques et les renommer. Vous avez également exploré des techniques plus avancées de renommage de champs, y compris l'utilisation d'expressions calculées et de champs imbriqués. Enfin, vous avez appris à calculer de nouveaux champs, à formater la sortie et à filtrer les résultats. Ces compétences sont essentielles pour traiter et analyser efficacement les données dans MongoDB.