Utiliser les références MongoDB

Introduction

Dans ce laboratoire, vous allez apprendre à utiliser les références MongoDB pour concevoir les relations de données et gérer les relations entre les documents parents et enfants. Vous commencerez par créer un système de gestion de bibliothèque simple avec des livres et des auteurs, puis explorer les techniques pour lier les documents parents et enfants, mettre à jour les références enfants, interroger les relations parent-enfant et maintenir l'intégrité référentielle. Le laboratoire couvre les principes clés des références de documents dans MongoDB et fournit des exemples pratiques pour vous aider à comprendre et appliquer efficacement ces concepts.

Skills Graph

Conception des relations de données

Dans cette étape, nous allons explorer comment concevoir des relations de données dans MongoDB en créant un exemple pratique de documents liés. Nous allons modéliser un système de gestion de bibliothèque simple avec des livres et des auteurs.

Comprendre les références de documents dans MongoDB

MongoDB propose deux principales façons de créer des relations entre des documents :

1. Documents incorporés
2. Références de documents

Pour notre système de bibliothèque, nous utiliserons des références de documents pour démontrer comment lier des données liées à travers des collections.

Commençons par ouvrir le shell MongoDB :

mongosh

Maintenant, créons notre base de données et nos collections :

use library_database

db.authors.insertOne({
    _id: ObjectId("author1"),
    name: "Jane Austen",
    nationality: "British",
    birthYear: 1775
})

db.books.insertOne({
    title: "Pride and Prejudice",
    author_id: ObjectId("author1"),
    published: 1813,
    genre: "Classic Literature"
})

Analyser la référence

Examinons ce que nous avons fait :

• Nous avons créé une collection authors avec un _id unique
• Nous avons créé une collection books qui référence l'auteur en utilisant author_id
• Le champ author_id contient l'_id du document auteur correspondant

Pour vérifier nos références, nous pouvons interroger les documents :

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

Exemple de sortie

{
  _id: ObjectId("author1"),
  name: 'Jane Austen',
  nationality: 'British',
  birthYear: 1775
}

{
  _id: ObjectId(...),
  title: 'Pride and Prejudice',
  author_id: ObjectId("author1"),
  published: 1813,
  genre: 'Classic Literature'
}

Principes clés des références de documents

• Utiliser l'_id pour créer des liens entre des documents
• Garder les références simples et cohérentes
• Choisir des références lorsque les données sont volumineuses ou changent fréquemment
• Normaliser les données pour réduire la duplication

Lier les documents parents et enfants

Dans cette étape, nous allons étendre notre base de données de bibliothèque en créant des relations plus complexes entre les documents parents et enfants. Nous allons démontrer comment lier plusieurs livres à un auteur et gérer efficacement ces relations.

Ajouter plusieurs livres pour un auteur

Continuons avec notre base de données existante et ajoutons plus de livres pour Jane Austen :

db.books.insertMany([
    {
        title: "Sense and Sensibility",
        author_id: ObjectId("author1"),
        published: 1811,
        genre: "Classic Literature"
    },
    {
        title: "Emma",
        author_id: ObjectId("author1"),
        published: 1815,
        genre: "Classic Literature"
    }
])

Interroger les documents liés

Pour trouver tous les livres de Jane Austen, nous utiliserons l'author_id :

db.books.find({ author_id: ObjectId("author1") })

Exemple de sortie

[
  {
    _id: ObjectId(...),
    title: 'Pride and Prejudice',
    author_id: ObjectId("author1"),
    published: 1813,
    genre: 'Classic Literature'
  },
  {
    _id: ObjectId(...),
    title: 'Sense and Sensibility',
    author_id: ObjectId("author1"),
    published: 1811,
    genre: 'Classic Literature'
  },
  {
    _id: ObjectId(...),
    title: 'Emma',
    author_id: ObjectId("author1"),
    published: 1815,
    genre: 'Classic Literature'
  }
]

Compter les livres d'un auteur

Nous pouvons également compter le nombre de livres d'un auteur spécifique :

db.books.countDocuments({ author_id: ObjectId("author1") })

Exemple de sortie

3

Interrogation avancée avec l'agrégation

Utilisons le cadre d'agrégation pour obtenir des informations plus détaillées :

db.books.aggregate([
    { $match: { author_id: ObjectId("author1") } },
    { $group: {
        _id: "$author_id",
        totalBooks: { $sum: 1 },
        earliestPublished: { $min: "$published" },
        latestPublished: { $max: "$published" }
    }}
])

Exemple de sortie

[
  {
    _id: ObjectId("author1"),
    totalBooks: 3,
    earliestPublished: 1811,
    latestPublished: 1815
  }
]

Mettre à jour les références enfants

Dans cette étape, nous allons apprendre à mettre à jour les références entre les documents parents et enfants dans MongoDB. Nous allons explorer différentes techniques pour modifier les références de documents et maintenir l'intégrité des données.

Ajouter un nouvel auteur et mettre à jour les références des livres

Commençons par ajouter un autre auteur à notre base de données :

db.authors.insertOne({
    _id: ObjectId("author2"),
    name: "Charles Dickens",
    nationality: "British",
    birthYear: 1812
})

Mettre à jour la référence de l'auteur d'un livre unique

Mettons à jour un livre pour changer sa référence d'auteur :

db.books.updateOne(
    { title: "Emma" },
    { $set: { author_id: ObjectId("author2") } }
)

Vérifier la mise à jour

Vérifions la référence de l'auteur du livre mis à jour :

db.books.findOne({ title: "Emma" })

Exemple de sortie

{
  _id: ObjectId(...),
  title: 'Emma',
  author_id: ObjectId("author2"),
  published: 1815,
  genre: 'Classic Literature'
}

Mise à jour en bloc des références

Nous pouvons également mettre à jour plusieurs documents d'un coup :

db.books.updateMany(
    { author_id: ObjectId("author1") },
    { $set: { genre: "Romantic Novel" } }
)

Vérifier les mises à jour de plusieurs documents

Vérifions la mise à jour du genre :

db.books.find({ author_id: ObjectId("author1") })

Exemple de sortie

[
  {
    _id: ObjectId(...),
    title: 'Pride and Prejudice',
    author_id: ObjectId("author1"),
    published: 1813,
    genre: 'Romantic Novel'
  },
  {
    _id: ObjectId(...),
    title: 'Sense and Sensibility',
    author_id: ObjectId("author1"),
    published: 1811,
    genre: 'Romantic Novel'
  }
]

Upsert : Mettre à jour ou insérer

Nous pouvons utiliser l'option upsert pour mettre à jour un document ou le créer s'il n'existe pas :

db.books.updateOne(
    { title: "Oliver Twist" },
    { $set: {
        author_id: ObjectId("author2"),
        published: 1837,
        genre: "Historical Fiction"
    }},
    { upsert: true }
)

Interroger les documents parents et enfants

Dans cette étape, nous allons explorer des techniques d'interrogation avancées pour récupérer des documents liés dans les collections parents et enfants de MongoDB. Nous allons démontrer comment trouver et joindre efficacement des données liées.

Requêtes de filtrage de base

Commençons par trouver les livres d'un auteur spécifique :

db.books.find({ author_id: ObjectId("author1") })

Filtrage avec plusieurs conditions

Interrogeons les livres avec plusieurs filtres :

db.books.find({
    author_id: ObjectId("author1"),
    published: { $gt: 1812 }
})

Cette requête trouve les livres de Jane Austen publiés après 1812.

Pipeline d'agrégation pour les requêtes complexes

Utilisons le cadre d'agrégation pour joindre les informations sur les auteurs et les livres :

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

Exemple de sortie

[
  {
    _id: ObjectId(...),
    title: 'Pride and Prejudice',
    published: 1813,
    author_name: ['Jane Austen']
  },
  {
    _id: ObjectId(...),
    title: 'Emma',
    published: 1815,
    author_name: ['Charles Dickens']
  }
]

Tri et limitation des résultats

Interrogeons et trions les livres par année de publication :

db.books.find()
  .sort({ published: 1 })
  .limit(2)

Cela récupère les deux premiers livres publiés.

Filtrage avancé avec des expressions régulières

Trouvons les livres dont le titre contient des mots spécifiques :

db.books.find({
    title: { $regex: /Sense/, $options: 'i' }
})

L'option $options: 'i' rend la recherche insensible à la casse.

Compter les documents liés

Comptez les livres pour chaque auteur :

db.books.aggregate([
    { $group: {
        _id: "$author_id",
        book_count: { $sum: 1 }
    }},
    { $lookup: {
        from: "authors",
        localField: "_id",
        foreignField: "_id",
        as: "author_info"
    }},
    { $project: {
        author_name: "$author_info.name",
        book_count: 1
    }}
])

Exemple de sortie

[
  {
    _id: ObjectId("author1"),
    author_name: ['Jane Austen'],
    book_count: 2
  },
  {
    _id: ObjectId("author2"),
    author_name: ['Charles Dickens'],
    book_count: 2
  }
]

Maintenir les références

Dans cette étape finale, nous allons explorer des stratégies pour maintenir les références de documents dans MongoDB, en mettant l'accent sur l'intégrité des données, le nettoyage et les meilleures pratiques pour gérer les relations entre les collections.

Gérer les références orphelines

Parfois, les références peuvent devenir obsolètes lorsque les documents parents sont supprimés. Montrez-vous comment gérer ceci :

Créer un auteur et un livre de test

db.authors.insertOne({
    _id: ObjectId("author3"),
    name: "Mark Twain",
    nationality: "American",
    birthYear: 1835
})

db.books.insertOne({
    title: "The Adventures of Tom Sawyer",
    author_id: ObjectId("author3"),
    published: 1876,
    genre: "Classic Literature"
})

Simuler le nettoyage des références

Supprimez un auteur et vérifiez les livres orphelins :

db.authors.deleteOne({ _id: ObjectId("author3") })

## Trouvez les livres avec des références d'auteurs inexistants
db.books.find({
    author_id: { $nin: db.authors.distinct("_id") }
})

Mettre en œuvre la gestion des références

Créez une fonction pour nettoyer les références orphelines :

db.books.deleteMany({
    author_id: { $nin: db.authors.distinct("_id") }
})

Empêcher les références invalides

Utilisez des règles de validation lors de l'insertion de documents :

db.createCollection("books", {
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: ["title", "author_id"],
         properties: {
            title: {
               bsonType: "string",
               description: "doit être une chaîne de caractères et est obligatoire"
            },
            author_id: {
               bsonType: "objectId",
               description: "doit être une référence d'auteur valide"
            }
         }
      }
   }
})

Indexer les références pour améliorer les performances

Créez un index sur le champ de référence :

db.books.createIndex({ author_id: 1 })

Vérifier la création de l'index

db.books.getIndexes()

Exemple de sortie

[
  { v: 2, key: { _id: 1 }, name: '_id_' },
  { v: 2, key: { author_id: 1 }, name: 'author_id_1' }
]

Meilleures pratiques pour la gestion des références

1. Toujours valider les références avant l'insertion
2. Utiliser des index sur les champs de référence
3. Mettre en œuvre des mécanismes de nettoyage
4. Considérez l'utilisation de transactions de base de données pour les opérations complexes

Monter la validation des références

## Cela échouera en raison d'un author_id invalide
db.books.insertOne({
    title: "Invalid Book",
    author_id: ObjectId("invalid_id")
})

Sommaire

Dans ce laboratoire, nous avons appris à concevoir des relations de données dans MongoDB en utilisant des références de documents. Nous avons créé un exemple pratique d'un système de gestion de bibliothèque, en modélisant des livres et des auteurs. Nous avons exploré les deux principales façons de créer des relations dans MongoDB : les documents imbriqués et les références de documents. Pour notre système de bibliothèque, nous avons choisi d'utiliser des références de documents pour lier des données liées entre les collections. Nous avons appris les principes clés des références de documents, tels que l'utilisation de _id pour créer des liens, le maintien des références simples et cohérentes, et le choix de références lorsque les données sont volumineuses ou changent fréquemment. Nous avons également étendu notre base de données de bibliothèque en créant des relations plus complexes entre les documents parents et enfants.