Mettre à jour les enregistrements MongoDB

Introduction

Dans ce laboratoire (lab), vous apprendrez à mettre à jour les enregistrements MongoDB en utilisant diverses techniques, notamment la mise à jour d'un seul document, la réalisation de mises à jour en bloc (bulk updates) et l'utilisation d'opérateurs de mise à jour. Vous explorerez également comment gérer les résultats des mises à jour et vérifier les données mises à jour. Ce laboratoire couvre les opérations CRUD (Create, Read, Update, Delete) fondamentales dans MongoDB, vous dotant des compétences nécessaires pour gérer efficacement vos données dans une base de données MongoDB.

Le laboratoire commence par démontrer comment mettre à jour un seul document en utilisant la méthode updateOne(), puis explore les mises à jour en bloc avec la méthode updateMany(). Vous allez ensuite plonger dans l'utilisation d'opérateurs de mise à jour, tels que $set, pour modifier des champs spécifiques dans les documents. De plus, vous apprendrez à gérer les résultats des mises à jour et à vérifier les données mises à jour pour garantir l'intégrité de vos enregistrements MongoDB.

Skills Graph

Mise à jour d'un seul document

Dans cette étape, vous apprendrez à mettre à jour un seul document dans MongoDB en utilisant la méthode updateOne(). Nous continuerons à travailler avec notre collection de livres et démontrerons comment modifier les attributs spécifiques d'un document.

Tout d'abord, connectons-nous au shell MongoDB et changeons de base de données pour mylab_database :

mongosh
use mylab_database

Pour commencer, vérifions les livres actuels dans notre collection :

db.books.find()

Vous devriez voir la liste des livres que nous avons ajoutés précédemment :

[
  {
    _id: ObjectId('674681ac7b1f6d3a37c1c18c'),
    title: 'JavaScript Fundamentals',
    author: 'Mike Johnson',
    year: 2022,
    pages: 350
  },
  {
    _id: ObjectId('674681ac7b1f6d3a37c1c18d'),
    title: 'Python Deep Dive',
    author: 'Sarah Williams',
    year: 2021,
    pages: 450
  },
  {
    _id: ObjectId('674681ac7b1f6d3a37c1c18e'),
    title: 'Machine Learning Basics',
    author: 'John Doe',
    year: 2020,
    price: 39.99
  }
]

Maintenant, nous utiliserons la méthode updateOne() pour modifier un document spécifique. Nous mettrons à jour le livre "JavaScript Fundamentals" pour changer son nombre de pages :

db.books.updateOne(
    { title: "JavaScript Fundamentals" },
    { $set: { pages: 400 } }
)

Décortiquons cette commande :

• Le premier argument { title: "JavaScript Fundamentals" } est le filtre qui permet de trouver le document spécifique à mettre à jour.
• $set est un opérateur de mise à jour qui change la valeur d'un champ spécifique.
• { pages: 400 } définit le nouveau nombre de pages à 400.

Pour vérifier la mise à jour, nous rechercherons à nouveau le document :

db.books.find({ title: "JavaScript Fundamentals" })

Vous devriez voir le document avec le nombre de pages mis à jour à 400.

Effectuer des mises à jour en bloc

Dans cette étape, vous apprendrez à effectuer des mises à jour en bloc (bulk updates) dans MongoDB en utilisant la méthode updateMany(). Les mises à jour en bloc sont très utiles lorsque vous devez modifier plusieurs documents qui correspondent à une condition spécifique.

Ajoutons quelques livres supplémentaires à notre collection pour démontrer les mises à jour en bloc :

db.books.insertMany([
    {
        title: "Advanced Python",
        author: "John Doe",
        year: 2019,
        price: 44.99
    },
    {
        title: "Data Science Handbook",
        author: "Jane Smith",
        year: 2021,
        price: 49.99
    }
])

Maintenant, effectuons une mise à jour en bloc pour augmenter le prix de tous les livres de John Doe de 10 dollars :

db.books.updateMany(
    { author: "John Doe" },
    { $inc: { price: 10 } }
)

Décortiquons cette commande :

• { author: "John Doe" } sélectionne tous les livres de John Doe.
• $inc est un opérateur de mise à jour qui incrémente le champ spécifié.
• { price: 10 } augmente le prix de 10.

Vérifions la mise à jour en recherchant tous les livres de John Doe :

db.books.find({ author: "John Doe" })

Vous devriez voir que les prix de "Machine Learning Basics" et "Advanced Python" ont augmenté de 10 dollars.

Effectuons une autre mise à jour en bloc en ajoutant une catégorie à tous les livres publiés avant 2021 :

db.books.updateMany(
    { year: { $lt: 2021 } },
    { $set: { category: "Older Publication" } }
)

Ici, $lt signifie "inférieur à", ce qui met à jour tous les livres publiés avant 2021 en ajoutant une catégorie "Older Publication".

Utiliser les opérateurs de mise à jour

Dans cette étape, vous explorerez les puissants opérateurs de mise à jour de MongoDB qui vous permettent d'effectuer des modifications complexes de documents au-delà de simples changements de valeurs.

Commençons par créer des données d'exemple avec lesquelles travailler :

db.products.insertMany([
    {
        name: "Laptop",
        price: 1000,
        tags: ["electronics", "computer"],
        stock: 50
    },
    {
        name: "Smartphone",
        price: 800,
        tags: ["electronics", "mobile"],
        stock: 30
    }
])

MongoDB propose plusieurs opérateurs de mise à jour puissants qui vous permettent de modifier les documents de manière sophistiquée :

1. Opérateur $mul - Multiplier des valeurs numériques

db.products.updateOne(
    { name: "Laptop" },
    { $mul: { price: 1.1 } }
)

La sortie :

{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0,
  upsertedId: null
}

L'opérateur $mul multiplie la valeur d'un champ par le nombre spécifié. Dans cet exemple, nous augmentons le prix de l'ordinateur portable de 10 %.

2. Opérateur $push - Ajouter des éléments à un tableau

db.products.updateOne(
    { name: "Smartphone" },
    { $push: { tags: "sale" } }
)

La sortie :

{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0,
  upsertedId: null
}

L'opérateur $push ajoute un élément à un champ de type tableau. Ici, nous ajoutons une étiquette "sale" aux étiquettes du smartphone.

3. Opérateurs $min et $max - Mise à jour basée sur une comparaison

db.products.updateOne(
    { name: "Laptop" },
    {
        $min: { stock: 40 },
        $max: { price: 1200 }
    }
)

La sortie :

{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0,
  upsertedId: null
}

• $min met à jour le champ si la valeur spécifiée est inférieure à la valeur existante
• $max met à jour le champ si la valeur spécifiée est supérieure à la valeur existante

Vérifions nos mises à jour :

db.products.find()

[
  {
    _id: ObjectId('674683aebec38876f7c1c18e'),
    name: 'Laptop',
    price: 1200,
    tags: [ 'electronics', 'computer' ],
    stock: 40
  },
  {
    _id: ObjectId('674683aebec38876f7c1c18f'),
    name: 'Smartphone',
    price: 800,
    tags: [ 'electronics', 'mobile', 'sale' ],
    stock: 30
  }
]

Vous devriez voir les documents modifiés avec les prix, les étiquettes et les niveaux de stock mis à jour.

Gérer les résultats des mises à jour

Dans cette étape, vous apprendrez à gérer et à interpréter les résultats des opérations de mise à jour dans MongoDB. Comprendre les résultats des mises à jour vous aide à vérifier que vos mises à jour ont été effectuées avec succès et à comprendre leur impact.

Commençons par créer des données d'exemple avec lesquelles travailler :

db.users.insertMany([
    { name: "Alice", age: 28, status: "active" },
    { name: "Bob", age: 35, status: "inactive" },
    { name: "Charlie", age: 42, status: "active" }
])

Maintenant, explorons différentes propriétés des résultats de mise à jour :

1. Résultat de mise à jour de base

const result = db.users.updateOne(
    { name: "Alice" },
    { $set: { age: 29 } }
)

print("Matched Documents: " + result.matchedCount)
print("Modified Documents: " + result.modifiedCount)

La sortie :

Matched Documents: 1
Modified Documents: 1

L'objet résultat fournit deux propriétés clés :

• matchedCount : Nombre de documents qui correspondent au filtre
• modifiedCount : Nombre de documents réellement modifiés

Cela vous aide à comprendre exactement ce qui s'est passé lors de l'opération de mise à jour. Si matchedCount est égal à 0, aucun document n'a été trouvé. Si modifiedCount est égal à 0, aucun changement n'a été effectué même si un document a été trouvé.

2. Opération d'upsert

db.users.updateOne(
    { name: "David" },
    { $set: { name: "David", age: 25, status: "active" } },
    { upsert: true }
)

Un upsert crée un nouveau document si aucun document correspondant n'est trouvé :

3. Résultats de mise à jour en bloc

db.users.updateMany(
    { status: "active" },
    { $inc: { age: 1 } }
)

Cela démontre comment obtenir les résultats d'une opération de mise à jour en bloc, en montrant combien d'utilisateurs actifs ont été trouvés et modifiés.

Vérifions nos mises à jour :

db.users.find()

Vérifier les données mises à jour

Dans cette étape, vous apprendrez diverses méthodes pour vérifier et interroger les données mises à jour dans MongoDB. Confirmer vos mises à jour est crucial pour maintenir l'intégrité des données et vous assurer que vos modifications sont appliquées correctement.

Créons des données d'exemple pour explorer les techniques de vérification :

db.inventory.insertMany([
    {
        item: "laptop",
        quantity: 25,
        status: "available",
        category: "electronics"
    },
    {
        item: "smartphone",
        quantity: 15,
        status: "low stock",
        category: "mobile"
    }
])

1. Requête de correspondance exacte pour une vérification précise

db.inventory.updateOne(
    { item: "laptop" },
    { $set: { quantity: 30 } }
)

const laptopUpdate = db.inventory.findOne({
    item: "laptop",
    quantity: 30
})

print("Laptop Update Verified: " + (laptopUpdate!== null))

La sortie :

Laptop Update Verified: true

Cette méthode vérifie si un document existe avec exactement les valeurs mises à jour. C'est le moyen le plus direct de confirmer une mise à jour spécifique.

2. Vérification basée sur une plage

db.inventory.updateMany(
    { status: "low stock" },
    { $inc: { quantity: 5 } }
)

const updatedItems = db.inventory.find({
    quantity: { $gte: 20 }
}).toArray()

print("Updated Low Stock Items: " + updatedItems.length)

La sortie :

Updated Low Stock Items: 2

L'utilisation d'opérateurs de comparaison comme $gte (supérieur ou égal à) vous permet de vérifier les mises à jour sur plusieurs documents.

3. Vérification par requête complexe

db.inventory.updateOne(
    { item: "smartphone" },
    { $set: { status: "in stock" } }
)

const verifyUpdate = db.inventory.findOne({
    item: "smartphone",
    status: "in stock",
    category: "mobile"
})

print("Smartphone Status Updated: " + (verifyUpdate!== null))

La sortie :

Smartphone Status Updated: true

Cela démontre une vérification plus complexe qui vérifie plusieurs conditions simultanément.

Affichons tous les documents pour confirmer nos mises à jour :

db.inventory.find()

Résumé

Dans ce laboratoire, vous avez appris à mettre à jour des documents uniques et multiples dans une base de données MongoDB. Vous avez commencé par utiliser la méthode updateOne() pour modifier un document spécifique, en changeant le nombre de pages du livre "JavaScript Fundamentals". Vous avez ensuite exploré la réalisation de mises à jour en bloc avec la méthode updateMany(), ce qui vous a permis de modifier plusieurs documents correspondant à une condition spécifique. De plus, vous avez appris à utiliser divers opérateurs de mise à jour, comme $set, que vous avez utilisé pour changer les valeurs des champs. Enfin, vous avez vérifié les données mises à jour pour vous assurer que les modifications ont été appliquées avec succès.