Projeter des champs MongoDB

Introduction

Dans ce laboratoire, vous allez apprendre à utiliser la projection MongoDB pour sélectionner et exclure des champs spécifiques lors de la requête de documents. La projection vous permet de contrôler les champs renvoyés dans les résultats de votre requête, vous permettant de réduire le transfert de données inutiles et d'améliorer les performances de la requête. Vous commencerez par sélectionner les champs à inclure, puis passerez à la spécification des champs à exclure, en combinant les champs à inclure et à exclure, en projetant des champs imbriqués et en formatant les champs de sortie. À la fin de ce laboratoire, vous aurez une compréhension solide de la manière d'utiliser efficacement la projection dans vos requêtes MongoDB.

Skills Graph

Sélectionner les champs à inclure

Dans cette étape, vous allez apprendre à utiliser la projection MongoDB pour sélectionner des champs spécifiques lors de la requête de documents. La projection vous permet de contrôler précisément les champs renvoyés dans les résultats de votre requête.

Tout d'abord, lançons le shell MongoDB et créons une collection d'échantillons avec laquelle travailler :

mongosh

Une fois dans le shell MongoDB, créons une base de données et ajoutons quelques documents d'utilisateurs d'échantillons :

use projectlab_database

db.users.insertMany([
    {
        name: "John Doe",
        age: 30,
        email: "[email protected]",
        city: "New York",
        job: "Software Engineer"
    },
    {
        name: "Jane Smith",
        age: 28,
        email: "[email protected]",
        city: "San Francisco",
        job: "Data Scientist"
    },
    {
        name: "Mike Johnson",
        age: 35,
        email: "[email protected]",
        city: "Chicago",
        job: "Product Manager"
    }
])

Maintenant, utilisons la projection pour sélectionner seulement des champs spécifiques. Pour inclure des champs, utilisez 1 dans le document de projection :

db.users.find({}, { name: 1, age: 1, _id: 0 });

Sortie d'exemple :

[
  { name: 'John Doe', age: 30 },
  { name: 'Jane Smith', age: 28 },
  { name: 'Mike Johnson', age: 35 }
]

Analysons la projection :

• { name: 1, age: 1, _id: 0 } signifie :
  • Inclure le champ name
  • Inclure le champ age
  • Exclure explicitement le champ _id (par défaut, _id est toujours renvoyé)

En utilisant la projection, vous pouvez contrôler précisément les champs renvoyés dans votre requête, réduire le transfert de données inutiles et améliorer les performances de la requête.

Spécifier les champs à exclure

Dans cette étape, vous allez apprendre à exclure des champs spécifiques des résultats de votre requête MongoDB en utilisant la projection. Cette technique vous permet d'éliminer les champs indésirables de la sortie du document.

Nous allons continuer à utiliser la collection users que nous avons créée dans l'étape précédente. Pour exclure des champs, utilisez 0 dans le document de projection :

db.users.find({}, { email: 0, city: 0 });

Sortie d'exemple :

[
  {
    _id: ObjectId("..."),
    name: 'John Doe',
    age: 30,
    job: 'Software Engineer'
  },
  {
    _id: ObjectId("..."),
    name: 'Jane Smith',
    age: 28,
    job: 'Data Scientist'
  },
  {
    _id: ObjectId("..."),
    name: 'Mike Johnson',
    age: 35,
    job: 'Product Manager'
  }
]

Règles de projection importantes à retenir :

• Vous ne pouvez pas mélanger l'inclusion et l'exclusion dans la même projection (sauf pour _id)
• _id est le seul champ que vous pouvez explicitement exclure tout en incluant d'autres champs
• Utiliser 0 supprime les champs spécifiés des résultats de la requête

Essayons un autre exemple en excluant plusieurs champs :

db.users.find({}, { email: 0, city: 0, _id: 0 });

Cette requête renverra des documents sans les champs email, city et _id, montrant seulement le nom, l'âge et le poste.

Mélanger inclusion et exclusion

Dans cette étape, vous allez découvrir les règles subtiles du mélange d'inclusion et d'exclusion dans les projections MongoDB. Bien que MongoDB n'autorise généralement pas le mélange d'inclusion et d'exclusion dans la même projection, il existe une exception spéciale pour le champ _id.

Explorons ce concept en utilisant notre collection users existante :

Tout d'abord, essayons un exemple qui illustre la règle générale :

// Cela entraînera une erreur
db.users.find({}, { name: 1, email: 0 });

Vous verrez un message d'erreur indiquant que vous ne pouvez pas mélanger les projections d'inclusion et d'exclusion.

Cependant, _id est un cas particulier. Vous pouvez inclure ou exclure d'autres champs tout en gérant explicitement le champ _id :

db.users.find(
  {},
  {
    _id: 0, // Exclure _id
    name: 1, // Inclure name
    job: 1 // Inclure job
  }
);

Sortie d'exemple :

[
  { name: 'John Doe', job: 'Software Engineer' },
  { name: 'Jane Smith', job: 'Data Scientist' },
  { name: 'Mike Johnson', job: 'Product Manager' }
]

Essayons un autre exemple avec une combinaison différente :

db.users.find(
  {},
  {
    _id: 0, // Exclure _id
    name: 1, // Inclure name
    age: 1, // Inclure age
    email: 0 // Cela entraînerait normalement une erreur, mais l'exception _id permet de le faire
  }
);

Idées clés :

• Vous ne pouvez pas mélanger l'inclusion et l'exclusion pour les champs normaux
• _id est le seul champ qui peut être explicitement inclus ou exclu lorsque d'autres champs sont projetés
• Soyez toujours explicite sur les champs que vous voulez inclure ou exclure

Projeter des champs imbriqués

Dans cette étape, vous allez apprendre à projeter des champs imbriqués dans les documents MongoDB. Les champs imbriqués sont des champs à l'intérieur de documents ou d'imbrications de tableaux, ce qui nécessite une approche légèrement différente pour la projection.

Tout d'abord, mettons à jour notre collection d'utilisateurs avec des documents plus complexes et imbriqués :

// Effacer les documents existants
db.users.deleteMany({});

// Insérer des documents avec des structures imbriquées
db.users.insertMany([
  {
    name: "John Doe",
    contact: {
      email: "[email protected]",
      phone: {
        mobile: "123-456-7890",
        work: "987-654-3210"
      }
    },
    skills: ["JavaScript", "MongoDB", "React"]
  },
  {
    name: "Jane Smith",
    contact: {
      email: "[email protected]",
      phone: {
        mobile: "234-567-8901",
        work: "876-543-2109"
      }
    },
    skills: ["Python", "Data Science", "Machine Learning"]
  }
]);

Pour projeter des champs imbriqués, utilisez la notation à point :

// Projeter des champs imbriqués spécifiques
db.users.find(
  {},
  {
    name: 1,
    "contact.email": 1,
    "contact.phone.mobile": 1,
    _id: 0
  }
);

Sortie d'exemple :

[
  {
    name: 'John Doe',
    contact: {
      email: '[email protected]',
      phone: { mobile: '123-456-7890' }
    }
  },
  {
    name: 'Jane Smith',
    contact: {
      email: '[email protected]',
      phone: { mobile: '234-567-8901' }
    }
  }
]

Vous pouvez également projeter des champs de tableau :

// Projeter les deux premières compétences
db.users.find(
  {},
  {
    name: 1,
    skills: { $slice: 2 },
    _id: 0
  }
);

Sortie d'exemple :

[
  {
    name: 'John Doe',
    skills: ['JavaScript', 'MongoDB']
  },
  {
    name: 'Jane Smith',
    skills: ['Python', 'Data Science']
  }
]

Points clés sur la projection de champs imbriqués :

• Utilisez la notation à point pour accéder aux champs imbriqués
• Vous pouvez projeter des champs profondément imbriqués
• Pour les tableaux, vous pouvez utiliser $slice pour limiter le nombre d'éléments renvoyés

Formater les champs de sortie

Dans cette étape, vous allez apprendre à formater et transformer les champs de sortie en utilisant les techniques de projection et d'agrégation de MongoDB. Nous allons explorer les façons de renommer, de calculer et de modifier les champs lors de la projection.

Tout d'abord, mettons à jour notre collection d'utilisateurs avec des informations plus détaillées :

// Effacer les documents existants
db.users.deleteMany({});

// Insérer des documents avec des données plus complexes
db.users.insertMany([
  {
    name: "John Doe",
    age: 30,
    salary: 75000,
    department: "Engineering"
  },
  {
    name: "Jane Smith",
    age: 28,
    salary: 85000,
    department: "Data Science"
  },
  {
    name: "Mike Johnson",
    age: 35,
    salary: 95000,
    department: "Management"
  }
]);

Utilisez l'opérateur $ pour renommer les champs lors de la projection :

db.users.find(
  {},
  {
    fullName: "$name",
    yearsOld: "$age",
    annualSalary: "$salary",
    _id: 0
  }
);

Sortie d'exemple :

[
  { fullName: 'John Doe', yearsOld: 30, annualSalary: 75000 },
  { fullName: 'Jane Smith', yearsOld: 28, annualSalary: 85000 },
  { fullName: 'Mike Johnson', yearsOld: 35, annualSalary: 95000 }
]

Vous pouvez également effectuer des calculs en utilisant les opérateurs d'agrégation $ :

db.users.aggregate([
  {
    $project: {
      name: 1,
      monthlySalary: { $divide: ["$salary", 12] },
      salaryTier: {
        $switch: {
          branches: [
            { case: { $lt: ["$salary", 80000] }, then: "Junior" },
            { case: { $gte: ["$salary", 80000] }, then: "Senior" }
          ],
          default: "Unknown"
        }
      },
      _id: 0
    }
  }
]);

Sortie d'exemple :

[
  {
    name: 'John Doe',
    monthlySalary: 6250,
    salaryTier: 'Junior'
  },
  {
    name: 'Jane Smith',
    monthlySalary: 7083.333333333333,
    salaryTier: 'Senior'
  },
  {
    name: 'Mike Johnson',
    monthlySalary: 7916.666666666667,
    salaryTier: 'Senior'
  }
]

Points clés sur le formattage des champs de sortie :

• Utilisez $ pour renommer les champs lors de la projection
• Le pipeline d'agrégation permet des transformations complexes de champs
• Vous pouvez effectuer des calculs et créer des champs conditionnels
• L'étape $project est puissante pour le formattage des champs

Sommaire

Dans ce laboratoire, vous allez apprendre à utiliser la fonction de projection de MongoDB pour sélectionner ou exclure des champs spécifiques lors de la requête de documents. Vous commencerez par inclure seulement les champs dont vous avez besoin, puis explorererez l'exclusion de champs indésirables, et enfin mélangerez l'inclusion et l'exclusion pour personnaliser la sortie. De plus, vous allez apprendre à projeter des champs imbriqués et à formater la sortie. Ces techniques vous permettent de contrôler les données renvoyées par vos requêtes, d'améliorer les performances et de réduire le transfert de données inutiles.