Comment mettre à jour les tableaux MongoDB

Introduction

Dans ce laboratoire, vous apprendrez à manipuler des tableaux (arrays) au sein des documents MongoDB. Vous pratiquerez l'ajout, la suppression et la mise à jour d'éléments de tableaux en utilisant les puissants opérateurs de mise à jour de MongoDB. Ce laboratoire fournit des instructions étape par étape et des exemples pratiques pour vous aider à maîtriser la gestion des tableaux dans vos bases de données MongoDB.

Vous commencerez par ajouter des éléments à un tableau en utilisant l'opérateur $push. Ensuite, vous apprendrez à supprimer des éléments en utilisant les opérateurs $pull et $pullAll. Vous explorerez également comment modifier des éléments spécifiques au sein d'un tableau et comment utiliser $addToSet pour garantir qu'un tableau ne contienne que des éléments uniques. Enfin, vous apprendrez à supprimer les doublons existants d'un tableau en utilisant un pipeline d'agrégation (aggregation pipeline).

Ajouter des éléments à un tableau avec `$push`

Dans cette étape, vous apprendrez à ajouter de nouveaux éléments à un tableau dans un document MongoDB en utilisant l'opérateur $push. Cet opérateur ajoute une valeur spécifiée à un tableau.

Tout d'abord, ouvrez le shell MongoDB pour interagir avec votre base de données. Toutes les opérations de base de données dans ce laboratoire seront effectuées dans ce shell.

mongosh

Une fois dans le shell, basculez vers la base de données arraylab. Cette base de données a été créée pour vous lors du processus de configuration.

use arraylab

Le script de configuration a également créé une collection students avec un document. Trouvons ce document pour voir son état actuel.

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

Vous devriez voir la sortie suivante, qui montre qu'Alice est inscrite à deux cours :

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

Maintenant, ajoutons un nouveau cours, "Data Structures", au tableau courses d'Alice en utilisant l'opérateur $push.

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

La méthode updateOne trouve un document correspondant au filtre { name: "Alice Johnson" } et applique la mise à jour { $push: { courses: "Data Structures" } }. L'opérateur $push ajoute le nouveau cours au tableau courses.

Vous pouvez également ajouter plusieurs éléments à la fois en combinant $push avec le modificateur $each. Ajoutons "Physics" et "Chemistry" au tableau.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $push: { courses: { $each: ["Physics", "Chemistry"] } } }
)

Pour confirmer que tous les nouveaux cours ont été ajoutés, exécutez à nouveau la commande findOne.

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

Le document mis à jour contient maintenant les cinq cours :

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

Supprimer des éléments d'un tableau

Dans cette étape, vous apprendrez à supprimer des éléments d'un tableau en utilisant les opérateurs $pull et $pullAll. $pull supprime toutes les occurrences d'une valeur spécifiée, tandis que $pullAll supprime toutes les occurrences de plusieurs valeurs spécifiées.

Vous devriez toujours être dans le shell mongosh de l'étape précédente. Commençons par supprimer le cours "Physics" de la liste d'Alice en utilisant l'opérateur $pull.

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

Cette commande trouve le document pour "Alice Johnson" et supprime la chaîne "Physics" de son tableau courses.

Ensuite, supprimons plusieurs cours à la fois. L'opérateur $pullAll est parfait pour cela. Nous allons supprimer "Mathematics" et "Chemistry".

db.students.updateOne(
    { name: "Alice Johnson" },
    { $pullAll: { courses: ["Mathematics", "Chemistry"] } }
)

Maintenant, vérifions l'état final du document pour voir quels cours restent.

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

La sortie montre que "Physics", "Mathematics" et "Chemistry" ont été supprimés, ne laissant que deux cours.

{
  _id: ObjectId('...'),
  name: 'Alice Johnson',
  courses: [ 'Computer Science', 'Data Structures' ]
}

Mettre à jour des éléments spécifiques dans un tableau

Dans cette étape, vous apprendrez à modifier des éléments spécifiques au sein d'un tableau. Ceci est utile lorsque votre tableau contient des objets et que vous devez mettre à jour un champ dans l'un de ces objets.

Tout d'abord, insérons un nouveau document d'étudiant. Le tableau courses de ce document contiendra des objets, chacun avec un name et une grade.

db.students.insertOne({
    name: "Bob Smith",
    courses: [
        { name: "Mathematics", grade: "B" },
        { name: "Computer Science", grade: "A" },
        { name: "Physics", grade: "C" }
    ]
})

Supposons que nous voulions changer la note de Bob en "Computer Science" de "A" à "A+". Nous pouvons utiliser l'opérateur positionnel $. Cet opérateur agit comme un espace réservé pour le premier élément qui correspond à la condition de la requête.

db.students.updateOne(
    { name: "Bob Smith", "courses.name": "Computer Science" },
    { $set: { "courses.$.grade": "A+" } }
)

Dans cette commande, la requête { "courses.name": "Computer Science" } identifie le bon élément du tableau. La mise à jour { $set: { "courses.$.grade": "A+" } } utilise ensuite $ pour faire référence à cet élément et mettre à jour son champ grade.

Vérifions le changement.

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

La sortie montrera la note mise à jour :

{
  _id: ObjectId('...'),
  name: 'Bob Smith',
  courses: [
    { name: 'Mathematics', grade: 'B' },
    { name: 'Computer Science', grade: 'A+' },
    { name: 'Physics', grade: 'C' }
  ]
}

Vous pouvez également mettre à jour tous les éléments d'un tableau en une seule fois en utilisant l'opérateur positionnel tout $[ ]. Ajoutons un champ semester à tous les cours de Bob.

db.students.updateOne(
    { name: "Bob Smith" },
    { $set: { "courses.$[].semester": "Fall 2023" } }
)

Vérifiez le document final pour voir le résultat.

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

Tous les objets de cours dans le tableau ont maintenant le champ semester.

{
  _id: ObjectId('...'),
  name: 'Bob Smith',
  courses: [
    { name: 'Mathematics', grade: 'B', semester: 'Fall 2023' },
    { name: 'Computer Science', grade: 'A+', semester: 'Fall 2023' },
    { name: 'Physics', grade: 'C', semester: 'Fall 2023' }
  ]
}

Garantir des éléments uniques avec `$addToSet`

Dans cette étape, vous apprendrez à utiliser l'opérateur $addToSet. Cet opérateur ajoute un élément à un tableau uniquement s'il n'existe pas déjà dans le tableau, empêchant ainsi les doublons.

Tout d'abord, ajoutons un nouvel étudiant avec un tableau de compétences.

db.students.insertOne({
    name: "Emma Wilson",
    skills: ["Python", "JavaScript"]
})

Maintenant, essayons d'ajouter à nouveau "Python" en utilisant $addToSet. Comme "Python" est déjà dans le tableau, cette opération ne modifiera pas le document.

db.students.updateOne(
    { name: "Emma Wilson" },
    { $addToSet: { skills: "Python" } }
)

Vérifions le document pour confirmer.

db.students.findOne({ name: "Emma Wilson" })

Vous verrez que le tableau skills n'a pas changé, car "Python" était déjà présent.

{
  _id: ObjectId('...'),
  name: 'Emma Wilson',
  skills: [ 'Python', 'JavaScript' ]
}

Comme $push, $addToSet peut être combiné avec le modificateur $each pour ajouter plusieurs valeurs. Il ajoutera uniquement les valeurs qui ne sont pas déjà dans le tableau.

db.students.updateOne(
    { name: "Emma Wilson" },
    { $addToSet: {
        skills: {
            $each: ["React", "Node.js", "Python", "TypeScript"]
        }
    } }
)

Vérifions le document final.

db.students.findOne({ name: "Emma Wilson" })

Les nouvelles compétences uniques ont été ajoutées, tandis que le doublon "Python" a été ignoré.

{
  _id: ObjectId('...'),
  name: 'Emma Wilson',
  skills: [ 'Python', 'JavaScript', 'React', 'Node.js', 'TypeScript' ]
}

Supprimer les doublons existants d'un tableau

Alors que $addToSet empêche l'ajout de nouveaux doublons, il arrive parfois qu'un document contienne déjà des valeurs en double dans un tableau. Dans cette étape, vous apprendrez à supprimer les doublons existants à l'aide d'un pipeline d'agrégation.

Tout d'abord, insérons un document avec un tableau skills contenant des doublons.

db.students.insertOne({
    name: "Michael Chen",
    skills: ["Python", "JavaScript", "Python", "React", "JavaScript", "Node.js"]
})

Pour supprimer ces doublons, nous pouvons utiliser un pipeline d'agrégation avec l'étape $merge. Ce pipeline lira le document, créera un nouveau tableau avec des éléments uniques, puis mettra à jour le document d'origine.

Tout d'abord, nous devons créer un index sur le champ name pour garantir que l'opération $merge fonctionne correctement :

db.students.createIndex({ name: 1 }, { unique: true })

Maintenant, exécutez la commande d'agrégation suivante :

db.students.aggregate([
    { $match: { name: "Michael Chen" } },
    { $project: {
        name: 1,
        skills: { $setUnion: "$skills" }
    } },
    { $merge: { into: "students", on: "name", whenMatched: "replace" } }
])

Décomposons ce pipeline :

$match : Cette étape filtre les documents pour ne traiter que celui de "Michael Chen".
$project : Cette étape remodèle le document. Nous conservons le champ name et remplaçons le tableau skills par le résultat de $setUnion: "$skills". L'opérateur $setUnion prend un tableau et renvoie un nouveau tableau contenant uniquement les éléments uniques.
$merge : Cette étape réécrit les résultats du pipeline dans la collection students. Elle trouve le document à mettre à jour en se basant sur le champ name (on: "name") et remplace l'intégralité du document par le nouveau provenant du pipeline (whenMatched: "replace"). L'index que nous avons créé garantit une correspondance et une mise à jour efficaces.

Vérifions maintenant que les doublons ont été supprimés.

db.students.findOne({ name: "Michael Chen" })

La sortie affichera le tableau skills avec uniquement des éléments uniques. L'ordre des éléments peut varier.

{
  _id: ObjectId('...'),
  name: 'Michael Chen',
  skills: [ 'JavaScript', 'Node.js', 'Python', 'React' ]
}

Résumé

Dans ce laboratoire, vous avez appris plusieurs techniques essentielles pour gérer les tableaux dans MongoDB. Vous avez pratiqué l'ajout d'éléments avec $push, leur suppression avec $pull et $pullAll, et la mise à jour d'éléments spécifiques à l'aide de l'opérateur positionnel $. Vous avez également exploré comment maintenir des éléments uniques dans un tableau avec $addToSet et comment nettoyer les doublons existants à l'aide d'un pipeline d'agrégation avec $setUnion et $merge. Ces compétences sont fondamentales pour construire des applications dynamiques et robustes avec MongoDB.

Mettre à jour les tableaux MongoDB