Gérer les tableaux MongoDB

MongoDBBeginner
Pratiquer maintenant

Introduction

Dans ce laboratoire, vous apprendrez à gérer les tableaux MongoDB. Les tableaux sont une structure de données fondamentale dans MongoDB qui vous permet de stocker des listes de valeurs au sein d'un seul document. Vous explorerez diverses opérations, notamment la création de documents avec des champs de tableau, l'ajout et la suppression d'éléments, la mise à jour de valeurs dans les tableaux et l'exécution de requêtes basées sur le contenu des tableaux. Ces compétences sont essentielles pour gérer efficacement des structures de données complexes dans MongoDB.

À la fin de ce laboratoire, vous aurez une compréhension solide et pratique du travail avec les tableaux MongoDB, vous permettant de construire des schémas de base de données plus sophistiqués et flexibles.

Créer des documents avec des champs de tableau

Dans cette première étape, vous vous connecterez au serveur MongoDB et créerez un nouveau document qui inclut un champ de tableau. Les tableaux sont puissants car ils vous permettent de stocker plusieurs valeurs liées, telles que des tags, des commentaires ou des cours, directement dans un document.

Tout d'abord, ouvrez le shell MongoDB pour commencer à interagir avec votre base de données. Vous effectuerez toutes les opérations ultérieures de ce laboratoire dans le shell mongosh.

mongosh

Une fois dans le shell, vous verrez une invite telle que test>. Passons à la base de données arraylab, qui a été pré-configurée pour ce laboratoire.

use arraylab

Le script setup a déjà créé une collection students et inséré un document. Maintenant, vous allez insérer un nouveau document pour un étudiant nommé "Alice Johnson". Ce document aura un champ courses, qui est un tableau de chaînes de caractères.

db.students.insertOne({
    name: "Alice Johnson",
    age: 22,
    courses: ["Mathematics", "Computer Science", "Physics"]
})

Cette commande insère un seul document dans la collection students. Le champ courses contient un tableau comportant trois éléments de type chaîne de caractères.

Pour confirmer que le document a été créé avec succès, vous pouvez utiliser la méthode find() pour récupérer tous les documents de la collection. La méthode .pretty() formate la sortie pour la rendre plus lisible.

db.students.find().pretty()

Vous devriez voir deux documents : celui de "Bob Smith" qui a été créé lors de la configuration, et le document "Alice Johnson" que vous venez d'ajouter.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 95, 87, 92 ],
    activities: [ 'Chess Club', 'Debate Team' ]
  },
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science', 'Physics' ]
  }
]

Ajouter des éléments à un tableau

Après avoir créé des tableaux, une tâche courante consiste à y ajouter de nouveaux éléments. Dans cette étape, vous apprendrez à utiliser l'opérateur $push pour ajouter des éléments à un tableau existant.

Pour ajouter un seul élément à un tableau, utilisez l'opérateur $push dans une opération de mise à jour. Ajoutons un nouveau cours, "Data Science", à la liste des cours d'Alice Johnson.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $push: { courses: "Data Science" } }
)

Dans cette commande, le premier argument { name: "Alice Johnson" } est le filtre qui trouve le document à mettre à jour. Le second argument { $push: { courses: "Data Science" } } spécifie l'action de mise à jour. $push ajoute la valeur "Data Science" au tableau courses.

Vérifions la modification en recherchant à nouveau le document d'Alice.

db.students.find({ name: "Alice Johnson" }).pretty()

La sortie affiche le nouveau cours ajouté au tableau.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science', 'Physics', 'Data Science' ]
  }
]

Pour ajouter plusieurs éléments à la fois, vous pouvez combiner $push avec le modificateur $each. Ajoutons deux nouvelles activités pour Bob Smith.

db.students.updateOne(
    { name: "Bob Smith" },
    { $push: { activities: { $each: ["Robotics Club", "Swimming Team"] } } }
)

Ici, $each indique à $push d'ajouter chaque élément de la liste fournie (["Robotics Club", "Swimming Team"]) au tableau activities.

Vérifiez également cette mise à jour :

db.students.find({ name: "Bob Smith" }).pretty()

La sortie confirme que les deux nouvelles activités ont été ajoutées.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 95, 87, 92 ],
    activities: [ 'Chess Club', 'Debate Team', 'Robotics Club', 'Swimming Team' ]
  }
]

Supprimer des éléments d'un tableau

Tout comme vous pouvez ajouter des éléments, vous devez également pouvoir les supprimer. MongoDB fournit plusieurs opérateurs à cet effet. Dans cette étape, vous apprendrez à utiliser $pull pour supprimer des éléments par valeur et $pop pour les supprimer par position.

Pour supprimer un élément spécifique d'un tableau en fonction de sa valeur, utilisez l'opérateur $pull. Supprimons "Physics" de la liste des cours d'Alice.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $pull: { courses: "Physics" } }
)

Cette commande trouve le document d'Alice et supprime toutes les occurrences de "Physics" de son tableau courses. Vérifiez le résultat :

db.students.find({ name: "Alice Johnson" }).pretty()

La sortie montre que "Physics" n'est plus dans le tableau.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science', 'Data Science' ]
  }
]

Pour supprimer plusieurs éléments qui correspondent à des valeurs dans une liste, vous pouvez utiliser l'opérateur $pullAll. Supprimons "Chess Club" et "Debate Team" des activités de Bob.

db.students.updateOne(
    { name: "Bob Smith" },
    { $pullAll: { activities: ["Chess Club", "Debate Team"] } }
)

Vérifiez la mise à jour du document de Bob :

db.students.find({ name: "Bob Smith" }).pretty()

La sortie confirme la suppression des activités spécifiées.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 95, 87, 92 ],
    activities: [ 'Robotics Club', 'Swimming Team' ]
  }
]

Si vous devez supprimer un élément du début ou de la fin d'un tableau, vous pouvez utiliser l'opérateur $pop. Utilisez 1 pour supprimer le dernier élément et -1 pour supprimer le premier. Supprimons le dernier cours de la liste d'Alice.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $pop: { courses: 1 } }
)

Voyons l'état final des cours d'Alice :

db.students.find({ name: "Alice Johnson" }).pretty()

La sortie montre que le dernier élément, "Data Science", a été supprimé.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science' ]
  }
]

Mettre à jour des éléments dans un tableau

La mise à jour des éléments existants dans un tableau est une autre opération cruciale. Cette étape couvre la manière de mettre à jour les éléments de tableau à l'aide d'opérateurs positionnels.

Pour mettre à jour un seul élément spécifique dans un tableau, vous devez d'abord faire correspondre le document et l'élément que vous souhaitez modifier. Ensuite, vous pouvez utiliser l'opérateur positionnel $ pour effectuer la mise à jour. Modifions "Mathematics" en "Advanced Mathematics" dans le tableau courses d'Alice.

db.students.updateOne(
    { name: "Alice Johnson", courses: "Mathematics" },
    { $set: { "courses.$": "Advanced Mathematics" } }
)

Dans cette commande, le filtre { name: "Alice Johnson", courses: "Mathematics" } trouve le document et identifie la position de la première occurrence de "Mathematics" dans le tableau. La mise à jour { $set: { "courses.$": "Advanced Mathematics" } } utilise courses.$ pour faire référence à la position de cet élément correspondant et définit sa nouvelle valeur.

Vérifiez la modification :

db.students.find({ name: "Alice Johnson" }).pretty()

La sortie montre le nom du cours mis à jour.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Advanced Mathematics', 'Computer Science' ]
  }
]

Pour mettre à jour tous les éléments d'un tableau qui correspondent à une condition, vous pouvez utiliser l'opérateur positionnel tout $[ ]. Augmentons toutes les notes de Bob de 5 points en utilisant l'opérateur $inc (incrément).

db.students.updateOne(
    { name: "Bob Smith" },
    { $inc: { "grades.$[]": 5 } }
)

Ici, grades.$[] applique l'opération $inc à chaque élément du tableau grades.

Vérifiez les nouvelles notes de Bob :

db.students.find({ name: "Bob Smith" }).pretty()

La sortie montre que chaque note a été augmentée de 5.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 100, 92, 97 ],
    activities: [ 'Robotics Club', 'Swimming Team' ]
  }
]

Interroger des documents en fonction du contenu du tableau

L'interrogation est au cœur de toute base de données. MongoDB offre un riche ensemble d'opérateurs pour interroger des documents en fonction du contenu de leurs tableaux. Dans cette dernière étape, vous apprendrez à trouver des documents en faisant correspondre des éléments de tableau et leurs propriétés.

Pour trouver tous les documents où un tableau contient un élément spécifique, vous pouvez inclure cette valeur dans votre filtre de requête. Trouvons tous les étudiants inscrits en "Computer Science".

db.students.find({ courses: "Computer Science" }).pretty()

Cette requête retournera le document d'Alice, car son tableau courses contient "Computer Science".

Pour trouver des documents où un tableau contient tous les éléments d'un ensemble spécifié, utilisez l'opérateur $all.

db.students.find({
    courses: { $all: ["Advanced Mathematics", "Computer Science"] }
}).pretty()

Ceci retournera également le document d'Alice car son tableau courses contient ces deux valeurs.

Pour des conditions plus complexes sur les éléments de tableau, l'opérateur $elemMatch est très utile. Il vous permet de spécifier plusieurs critères qu'un seul élément de tableau doit satisfaire. Trouvons les étudiants qui ont au moins une note supérieure à 95.

db.students.find({
    grades: { $elemMatch: { $gt: 95 } }
}).pretty()

Cette requête retournera le document de Bob, car il a des notes supérieures à 95. $gt signifie "greater than" (supérieur à).

Vous pouvez également interroger en fonction du nombre d'éléments dans un tableau en utilisant l'opérateur $size. Trouvons les étudiants qui participent à exactement deux activités.

db.students.find({
    activities: { $size: 2 }
}).pretty()

Ceci retournera le document de Bob, car son tableau activities contient actuellement deux éléments.

Enfin, ajoutons un étudiant de plus pour pratiquer une requête combinée.

db.students.insertOne({
    name: "Charlie Brown",
    courses: ["Art", "Music", "Literature"],
    grades: [88, 92, 85],
    activities: ["Painting Club"]
})

Maintenant, trouvons les étudiants qui suivent soit "Art", soit "Music" (en utilisant l'opérateur $in) ET qui ont au moins une note supérieure ou égale à 90 (en utilisant $elemMatch avec $gte).

db.students.find({
    courses: { $in: ["Art", "Music"] },
    grades: { $elemMatch: { $gte: 90 } }
}).pretty()

Cette requête retournera le document de "Charlie Brown", qui remplit les deux conditions.

Résumé

Dans ce laboratoire, vous avez appris les techniques fondamentales pour gérer les tableaux dans MongoDB. Vous avez commencé par créer des documents avec des champs de tableau, puis vous vous êtes exercé à ajouter des éléments à l'aide de $push et $each. Vous avez exploré la suppression d'éléments par valeur avec $pull et $pullAll, et par position avec $pop. Vous avez également appris à mettre à jour des éléments de tableau spécifiques à l'aide de l'opérateur positionnel $ et tous les éléments avec l'opérateur $[ ]. Enfin, vous vous êtes exercé à interroger des documents en fonction du contenu du tableau à l'aide d'opérateurs tels que $all, $elemMatch, $size et $in. Ces compétences sont cruciales pour construire et gérer des applications avec des structures de données complexes et imbriquées dans MongoDB.