Lier des documents MongoDB

Introduction

Dans ce laboratoire, vous allez apprendre à établir des relations entre les documents MongoDB, y compris la création de références de documents, la mise à jour des données liées, la requête des documents liés, la suppression des liens de documents et l'assurance de l'intégrité des données. Le laboratoire couvre les techniques fondamentales pour travailler avec les relations MongoDB, telles que l'utilisation de l'étape d'agrégation $lookup pour joindre des collections et la mise à jour de documents dans des collections liées. À la fin du laboratoire, vous aurez une compréhension solide de la manière de gérer les relations dans votre base de données MongoDB.

Skills Graph

Créer des références de documents

Dans cette étape, vous allez apprendre à créer des références de documents dans MongoDB, qui est une technique fondamentale pour établir des relations entre différentes collections.

Tout d'abord, lançons le shell MongoDB :

mongosh

Nous allons créer deux collections pour démontrer la référence de documents : authors et books. Il s'agit d'un scénario courant où les livres sont liés à leurs auteurs.

Créez la collection authors :

use library_database

db.authors.insertMany([
    {
        _id: ObjectId("660a1f5c9b8f8b1234567890"),
        name: "Jane Austen",
        nationality: "British"
    },
    {
        _id: ObjectId("660a1f5c9b8f8b1234567891"),
        name: "George Orwell",
        nationality: "British"
    }
])

Sortie exemple :

{
  acknowledged: true,
  insertedIds: {
    '0': ObjectId("660a1f5c9b8f8b1234567890"),
    '1': ObjectId("660a1f5c9b8f8b1234567891")
  }
}

Maintenant, créons la collection books avec des références aux auteurs :

db.books.insertMany([
    {
        title: "Pride and Prejudice",
        author_id: ObjectId("660a1f5c9b8f8b1234567890"),
        year: 1813
    },
    {
        title: "1984",
        author_id: ObjectId("660a1f5c9b8f8b1234567891"),
        year: 1949
    }
])

Sortie exemple :

{
  acknowledged: true,
  insertedIds: {
    '0': ObjectId("660b2a1c9b8f8b1234567892"),
    '1': ObjectId("660b2a1c9b8f8b1234567893")
  }
}

Vérifions les références en interrogeant les livres avec les détails de leurs auteurs :

db.books.aggregate([
    {
        $lookup: {
            from: "authors",
            localField: "author_id",
            foreignField: "_id",
            as: "author_details"
        }
    }
])

Cela montre comment créer des références de documents dans MongoDB. Nous avons lié les livres à leurs auteurs en utilisant le champ author_id, qui contient l'ObjectId de l'auteur correspondant.

Mettre à jour des données liées

Dans cette étape, vous allez apprendre à mettre à jour des documents liés dans MongoDB, en vous appuyant sur les références de documents que nous avons créées dans l'étape précédente.

Tout d'abord, assurez-vous d'être connecté au shell MongoDB et d'utiliser la base de données library_database :

mongosh
use library_database

Mettons à jour les informations d'un auteur. Nous allons modifier les détails de Jane Austen :

db.authors.updateOne(
    { _id: ObjectId("660a1f5c9b8f8b1234567890") },
    {
        $set: {
            birth_year: 1775,
            notable_works: ["Pride and Prejudice", "Sense and Sensibility"]
        }
    }
)

Sortie exemple :

{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1
}

Maintenant, mettons à jour les détails d'un livre tout en conservant sa référence :

db.books.updateOne(
    { title: "Pride and Prejudice" },
    {
        $set: {
            genre: "Romance",
            pages: 432,
            rating: 4.5
        }
    }
)

Sortie exemple :

{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1
}

Vérifions les mises à jour en interrogeant les détails complets :

db.authors.findOne({ name: "Jane Austen" })
db.books.findOne({ title: "Pride and Prejudice" })

Cela montre comment mettre à jour des documents liés tout en conservant leurs références. L'opérateur $set vous permet d'ajouter ou de modifier des champs spécifiques sans remplacer l'ensemble du document.

Interroger des documents liés

Dans cette étape, vous allez apprendre des techniques avancées pour interroger des documents liés dans MongoDB en utilisant l'étape de pipeline d'agrégation $lookup.

Tout d'abord, assurez-vous d'être connecté au shell MongoDB :

mongosh
use library_database

Effectuons une recherche simple pour joindre les livres à leurs auteurs :

db.books.aggregate([
    {
        $lookup: {
            from: "authors",
            localField: "author_id",
            foreignField: "_id",
            as: "author_details"
        }
    }
])

Maintenant, créons une requête plus complexe pour filtrer les livres par nationalité de l'auteur :

db.books.aggregate([
    {
        $lookup: {
            from: "authors",
            localField: "author_id",
            foreignField: "_id",
            as: "author_details"
        }
    },
    {
        $match: {
            "author_details.nationality": "British"
        }
    },
    {
        $project: {
            title: 1,
            year: 1,
            "author_name": { $arrayElemAt: ["$author_details.name", 0] }
        }
    }
])

Créons une autre requête pour trouver les livres publiés après 1900 :

db.books.aggregate([
    {
        $lookup: {
            from: "authors",
            localField: "author_id",
            foreignField: "_id",
            as: "author_details"
        }
    },
    {
        $match: {
            year: { $gt: 1900 }
        }
    },
    {
        $project: {
            title: 1,
            year: 1,
            "author_name": { $arrayElemAt: ["$author_details.name", 0] }
        }
    }
])

Ces requêtes démontrent différentes façons d'interroger et de combiner des documents liés en utilisant le cadre d'agrégation de MongoDB.

Supprimer les liens de documents

Dans cette étape, vous allez apprendre à supprimer les liens de documents et à gérer les documents liés dans MongoDB.

Tout d'abord, assurez-vous d'être connecté au shell MongoDB :

mongosh
use library_database

Commencez par supprimer un livre spécifique tout en conservant l'auteur :

db.books.deleteOne({ title: "1984" })

Sortie exemple :

{ acknowledged: true, deletedCount: 1 }

Maintenant, supprimons un auteur et tous leurs livres associés en utilisant un processus en plusieurs étapes :

// Tout d'abord, trouvez l'ID de l'auteur
const authorToRemove = db.authors.findOne({ name: "George Orwell" })

// Supprimez tous les livres de cet auteur
db.books.deleteMany({ author_id: authorToRemove._id })

// Ensuite, supprimez l'auteur
db.authors.deleteOne({ _id: authorToRemove._id })

Montrez une approche de suppression douce en ajoutant un champ d'état :

db.books.updateOne(
    { title: "Pride and Prejudice" },
    {
        $set: {
            status: "archivé",
            archived_date: new Date()
        }
    }
)

Pour interroger uniquement les livres actifs :

db.books.find({
    $or: [
        { status: { $exists: false } },
        { status: { $ne: "archivé" } }
    ]
})

Ces méthodes montrent différentes stratégies pour gérer les liens de documents et supprimer les documents liés.

Vérifier l'intégrité des données

Dans cette étape, vous allez apprendre des techniques pour garantir l'intégrité des données dans les relations de documents MongoDB.

Tout d'abord, assurez-vous d'être connecté au shell MongoDB :

mongosh
use library_database

Créez une règle de validation pour la collection authors :

db.createCollection("authors", {
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: ["name", "nationality"],
         properties: {
            name: {
               bsonType: "string",
               description: "doit être une chaîne de caractères et est obligatoire"
            },
            nationality: {
               bsonType: "string",
               description: "doit être une chaîne de caractères et est obligatoire"
            },
            birth_year: {
               bsonType: "int",
               minimum: 1500,
               maximum: 2023,
               description: "doit être un entier compris entre 1500 et 2023"
            }
         }
      }
   }
})

Créons une fonction pour vérifier les références orphelines :

function checkOrphanedReferences() {
    const orphanedBooks = db.books.aggregate([
        {
            $lookup: {
                from: "authors",
                localField: "author_id",
                foreignField: "_id",
                as: "author_exists"
            }
        },
        {
            $match: {
                author_exists: { $size: 0 }
            }
        }
    ]).toArray()

    print("Livres orphelins :", orphanedBooks.length)
    return orphanedBooks
}

checkOrphanedReferences()

Créez une vérification d'intégrité des données pour les documents de livres :

function validateBookDocuments() {
    const invalidBooks = db.books.find({
        $or: [
            { title: { $not: { $type: "string" } } },
            { year: { $not: { $type: "int" } } },
            { year: { $lt: 0 } }
        ]
    }).toArray()

    print("Livres invalides :", invalidBooks.length)
    return invalidBooks
}

validateBookDocuments()

Montrez une vérification d'intégrité référentielle :

function checkReferentialIntegrity() {
    const authorIds = db.authors.distinct("_id")
    const bookAuthorIds = db.books.distinct("author_id")

    const missingAuthors = bookAuthorIds.filter(
        id =>!authorIds.some(authorId => authorId.equals(id))
    )

    print("Références d'auteurs manquantes :", missingAuthors.length)
    return missingAuthors
}

checkReferentialIntegrity()

Récapitulatif

Dans ce laboratoire, vous avez appris à créer des références de documents dans MongoDB, qui est une technique fondamentale pour établir des relations entre différentes collections. Vous avez créé deux collections, "authors" et "books", et lié les livres à leurs auteurs en utilisant le champ "author_id". Vous avez également appris à interroger les documents liés en utilisant l'étape d'agrégation $lookup. En outre, vous avez exploré la manière de mettre à jour des documents liés, d'interroger des documents liés, de supprimer les liens de documents et d'assurer l'intégrité des données lorsqu'on travaille avec des références de documents dans MongoDB.