Introduction
Dans ce laboratoire, vous apprendrez à utiliser la projection MongoDB pour contrôler les champs qui apparaissent dans les résultats de vos requêtes. La projection est une fonctionnalité puissante qui vous permet de sélectionner des champs spécifiques à retourner, ce qui peut réduire la quantité de données transférées sur le réseau et améliorer les performances des requêtes. Vous pratiquerez l'inclusion et l'exclusion de champs, la projection de champs dans des documents imbriqués, et l'utilisation du framework d'agrégation pour remodeler la sortie. À la fin de ce laboratoire, vous aurez une solide compréhension de la manière d'utiliser efficacement la projection dans vos requêtes MongoDB.
Sélectionner des champs spécifiques avec la projection
Dans cette première étape, vous apprendrez les bases de la projection en sélectionnant uniquement les champs spécifiques que vous souhaitez voir dans les résultats de vos requêtes. C'est ce qu'on appelle une projection "inclusive".
Tout d'abord, ouvrez le MongoDB Shell. Cette interface interactive en ligne de commande est l'endroit où vous exécuterez toutes vos commandes de base de données pour ce laboratoire.
mongosh
Vous êtes maintenant dans le MongoDB Shell. L'invite de votre terminal changera pour indiquer que vous êtes connecté. Passons à une nouvelle base de données nommée projectlab_database et insérons quelques données d'exemple. Si la base de données n'existe pas, MongoDB la créera pour vous lorsque vous stockerez des données pour la première fois.
use projectlab_database
Ensuite, insérez trois documents dans une collection nommée users.
db.users.insertMany([
{
name: "John Doe",
age: 30,
email: "john.doe@example.com",
city: "New York",
job: "Software Engineer"
},
{
name: "Jane Smith",
age: 28,
email: "jane.smith@example.com",
city: "San Francisco",
job: "Data Scientist"
},
{
name: "Mike Johnson",
age: 35,
email: "mike.johnson@example.com",
city: "Chicago",
job: "Product Manager"
}
]);
Maintenant, interrogeons cette collection. Pour retourner uniquement les champs name et age pour tous les documents, vous ajoutez un document de projection comme deuxième argument à la méthode find(). Dans le document de projection, vous spécifiez les champs à inclure avec un 1. Par défaut, le champ _id est toujours retourné. Vous pouvez l'exclure explicitement en définissant sa valeur sur 0.
db.users.find({}, { name: 1, age: 1, _id: 0 });
Vous devriez voir la sortie suivante, qui ne contient que les champs name et age pour chaque utilisateur :
[
{ "name": "John Doe", "age": 30 },
{ "name": "Jane Smith", "age": 28 },
{ "name": "Mike Johnson", "age": 35 }
]
Cette technique est très utile pour récupérer uniquement les données nécessaires, ce qui est particulièrement important lorsque l'on travaille avec de gros documents.
Exclure des champs spécifiques des résultats
En plus de sélectionner les champs à inclure, vous pouvez également spécifier les champs à exclure. C'est ce qu'on appelle une projection "exclusive" et elle est utile lorsque vous souhaitez voir la plupart des champs mais en masquer quelques-uns, tels que des champs sensibles ou volumineux.
Vous devriez toujours être dans le shell mongosh avec la base de données projectlab_database sélectionnée.
Pour exclure des champs, vous définissez leur valeur sur 0 dans le document de projection. Exécutons une requête pour récupérer toutes les données utilisateur mais exclure les champs email et city.
db.users.find({}, { email: 0, city: 0 });
La sortie inclura tous les champs à l'exception de email et city. Notez que le champ _id est toujours inclus par défaut.
[
{
_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'
}
]
Une règle clé dans la projection est que vous ne pouvez pas mélanger l'inclusion (1) et l'exclusion (0) dans le même document de projection. La seule exception à cette règle est le champ _id. Vous pouvez exclure explicitement le champ _id (_id: 0) même lorsque vous incluez d'autres champs, comme vous l'avez fait à l'étape précédente. Vous pouvez également l'exclure dans une projection exclusive.
Par exemple, pour exclure email, city et _id, vous exécuteriez ce qui suit :
db.users.find({}, { email: 0, city: 0, _id: 0 });
Cette requête retourne les documents contenant uniquement les champs name, age et job.
Projeter des champs dans des documents imbriqués
Les données du monde réel sont souvent structurées avec des documents et des tableaux imbriqués. Les capacités de projection de MongoDB vous permettent de sélectionner précisément des champs, même lorsqu'ils sont profondément intégrés dans la structure d'un document.
Tout d'abord, effaçons la collection users existante et insérons de nouveaux documents qui ont un objet contact imbriqué et un tableau skills.
db.users.deleteMany({});
Maintenant, insérons les nouvelles données.
db.users.insertMany([
{
name: "John Doe",
contact: {
email: "john.doe@example.com",
phone: {
mobile: "123-456-7890",
work: "987-654-3210"
}
},
skills: ["JavaScript", "MongoDB", "React"]
},
{
name: "Jane Smith",
contact: {
email: "jane.smith@example.com",
phone: {
mobile: "234-567-8901",
work: "876-543-2109"
}
},
skills: ["Python", "Data Science", "Machine Learning"]
}
]);
Pour projeter un champ à l'intérieur d'un document imbriqué, vous utilisez la "notation par points" (dot notation). Par exemple, pour sélectionner le name de l'utilisateur et son numéro de téléphone mobile, vous spécifieriez "contact.phone.mobile": 1. Essayons de projeter le name, l'email et le numéro de téléphone mobile.
db.users.find(
{},
{
name: 1,
"contact.email": 1,
"contact.phone.mobile": 1,
_id: 0
}
);
Le résultat conservera la structure imbriquée pour les champs sélectionnés :
[
{
"name": "John Doe",
"contact": {
"email": "john.doe@example.com",
"phone": { "mobile": "123-456-7890" }
}
},
{
"name": "Jane Smith",
"contact": {
"email": "jane.smith@example.com",
"phone": { "mobile": "234-567-8901" }
}
}
]
Vous pouvez également projeter une partie d'un tableau en utilisant l'opérateur $slice. Pour obtenir le name et seulement les deux premiers skills pour chaque utilisateur, exécutez la commande suivante :
db.users.find({}, { name: 1, skills: { $slice: 2 }, _id: 0 });
La sortie affichera chaque utilisateur avec un tableau skills contenant seulement deux éléments :
[
{ "name": "John Doe", "skills": ["JavaScript", "MongoDB"] },
{ "name": "Jane Smith", "skills": ["Python", "Data Science"] }
]
Remodeler les champs de sortie avec l'agrégation
Pour des transformations plus avancées, telles que le renommage de champs ou la création de nouveaux champs calculés, la projection de la méthode find() n'est pas suffisante. Vous pouvez plutôt utiliser le framework d'agrégation, spécifiquement l'étape $project.
Préparons nos données pour cette étape. Effacez la collection et insérez des utilisateurs avec des informations salariales.
db.users.deleteMany({});
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"
}
]);
L'étape $project dans un pipeline d'agrégation peut remodeler les documents en ajoutant de nouveaux champs, en renommant des champs existants ou en supprimant des champs. Pour l'utiliser, vous passez un tableau d'étapes à la méthode aggregate().
Pour renommer un champ, vous définissez un nouveau nom de champ et lui attribuez la valeur d'un champ existant, précédé d'un signe $. Renommons name en fullName et age en yearsOld.
db.users.aggregate([
{
$project: {
fullName: "$name",
yearsOld: "$age",
_id: 0
}
}
]);
Vous pouvez également créer de nouveaux champs basés sur des calculs. Créons un champ monthlySalary en divisant le salary annuel par 12, et un champ salaryTier basé sur une logique conditionnelle à l'aide de l'opérateur $switch.
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
}
}
]);
La sortie sera une structure de document complètement nouvelle que vous avez définie dans l'étape $project :
[
{ "name": "John Doe", "monthlySalary": 6250, "salaryTier": "Junior" },
{
"name": "Jane Smith",
"monthlySalary": 7083.333333333333,
"salaryTier": "Senior"
},
{
"name": "Mike Johnson",
"monthlySalary": 7916.666666666667,
"salaryTier": "Senior"
}
]
L'étape $project vous donne un contrôle total sur la forme finale des résultats de votre requête, permettant des transformations de données puissantes directement dans la base de données.
Résumé
Dans ce laboratoire, vous avez appris à contrôler efficacement la sortie de vos requêtes MongoDB à l'aide de la projection. Vous avez commencé par les bases de l'inclusion et de l'exclusion de champs avec la méthode find(). Vous êtes ensuite passé à des sujets plus avancés, tels que l'utilisation de la notation par points (dot notation) pour projeter des champs dans des documents imbriqués et l'utilisation de l'opérateur $slice pour retourner un sous-ensemble d'un tableau. Enfin, vous avez exploré la puissance de l'étape $project du framework d'agrégation pour remodeler complètement les documents en renommant des champs, en créant de nouveaux champs calculés et en appliquant une logique conditionnelle. Ces compétences sont fondamentales pour écrire des requêtes efficaces et précises dans MongoDB.
