Insérer des données dans MongoDB

Introduction

Dans ce laboratoire (lab), vous apprendrez à insérer des données dans MongoDB en utilisant diverses méthodes et à explorer les techniques de manipulation de données de base. Grâce à une série d'exercices pratiques, vous allez pratiquer l'insertion de documents uniques et multiples, gérer les erreurs potentielles et vérifier l'intégrité des données à l'aide du shell MongoDB.

Le laboratoire couvre les opérations CRUD (Create, Read, Update, Delete - Créer, Lire, Mettre à jour, Supprimer) essentielles, en mettant l'accent sur les stratégies d'insertion de documents. Vous allez créer une base de données de librairie (bookstore), insérer des documents avec différentes structures, gérer les contraintes d'index unique et valider les schémas de documents. À la fin de ce laboratoire, vous aurez une bonne compréhension de la manière d'ajouter et de gérer efficacement les données dans MongoDB.

Skills Graph

Insertion d'un document unique

Bienvenue dans le laboratoire pratique (hands-on lab) MongoDB! Dans cette première étape, nous allons explorer comment insérer des documents dans une collection MongoDB. MongoDB est une base de données NoSQL puissante qui stocke les données dans des documents flexibles, similaires au format JSON, ce qui le rend incroyablement polyvalent pour diverses besoins d'application.

Comprendre les bases de MongoDB

Avant de commencer, discutons brièvement de ce que nous allons faire. Nous allons créer une base de données de librairie (bookstore) et apprendre à insérer des documents représentant des livres. Cela vous aidera à comprendre les techniques fondamentales d'insertion de documents dans MongoDB.

Se connecter à MongoDB

Tout d'abord, ouvrez un terminal et connectez-vous à MongoDB en utilisant mongosh :

mongosh

Vous devriez voir l'invite du shell MongoDB, ce qui indique une connexion réussie.

Créer une base de données et une collection

Créons une nouvelle base de données appelée bookstore et une collection nommée books :

use bookstore
db.createCollection("books")

Exemple de sortie :

switched to db bookstore
{ ok: 1 }

Insérer un document unique

Maintenant, insérons un document unique représentant un livre dans la collection books :

db.books.insertOne({
  title: "The Great Gatsby",
  author: "F. Scott Fitzgerald",
  year: 1925,
  genres: ["Classic", "Fiction"]
})

Exemple de sortie :

{
  acknowledged: true,
  insertedId: ObjectId("...unique-object-id...")
}

Remarquez comment MongoDB génère automatiquement un _id unique pour chaque document. Cela permet de s'assurer que chaque document peut être identifié de manière unique dans la collection.

Insertion en bloc de documents

Dans cette étape, nous allons élargir notre collection de la librairie (bookstore) en apprenant à insérer plusieurs documents simultanément. L'insertion en bloc est une méthode efficace pour ajouter plusieurs enregistrements en une seule opération.

Préparer l'insertion en bloc

Nous continuerons à travailler dans la base de données bookstore et ajouterons plusieurs documents de livres d'un coup :

use bookstore

Insérer plusieurs documents

Utilisez la méthode insertMany() pour ajouter plusieurs documents de livres :

db.books.insertMany([
  {
    title: "1984",
    author: "George Orwell",
    year: 1949,
    genres: ["Dystopian", "Science Fiction"]
  },
  {
    title: "To Kill a Mockingbird",
    author: "Harper Lee",
    year: 1960,
    genres: ["Classic", "Fiction"]
  },
  {
    title: "Pride and Prejudice",
    author: "Jane Austen",
    year: 1813,
    genres: ["Romance", "Classic"]
  }
])

Exemple de sortie :

{
  acknowledged: true,
  insertedIds: {
    '0': ObjectId("..."),
    '1': ObjectId("..."),
    '2': ObjectId("...")
  }
}

Vérifier les documents insérés

Vérifions le nombre de documents dans la collection :

db.books.countDocuments()

Exemple de sortie :

4

Cela montre que nous avons maintenant 4 documents dans notre collection.

Vérifier les résultats de l'insertion

Dans cette étape, nous allons explorer comment récupérer et examiner les documents que nous avons insérés dans notre collection MongoDB. Cela est crucial pour vérifier les données et effectuer des requêtes.

Trouver tous les documents

Utilisez la méthode find() pour récupérer tous les documents de la collection books :

use bookstore
db.books.find()

L'exemple de sortie affichera tous les détails des documents avec toutes leurs informations.

Trouver des documents spécifiques

Récupérez des documents en utilisant des critères spécifiques :

## Find books published before 1950
db.books.find({ year: { $lt: 1950 } })

L'exemple de sortie montrera les livres publiés avant 1950.

Trouver des documents avec des champs spécifiques

Récupérez des champs spécifiques des documents :

## Find titles and authors of classic books
db.books.find(
  { genres: "Classic" },
  { title: 1, author: 1, _id: 0 }
)

Cette commande ne renvoie que les titres et les auteurs des livres classiques, en excluant le champ _id.

Gérer les erreurs d'insertion

Dans cette étape, nous allons apprendre à gérer les erreurs potentielles lors de l'insertion de documents, ce qui est essentiel pour maintenir l'intégrité des données dans votre base de données MongoDB.

Créer un index unique

Tout d'abord, créez un index unique sur le champ title pour éviter les titres de livres en double :

use bookstore
db.books.createIndex({ title: 1 }, { unique: true })

Exemple de sortie :

title_1

Tenter d'insérer un document en double

Essayez d'insérer un document avec un titre qui existe déjà :

db.books.insertOne({
  title: "1984",
  author: "George Orwell",
  year: 1949,
  genres: ["Dystopian", "Science Fiction"]
})

Cela entraînera une erreur de clé en double.

Gérer les erreurs d'insertion avec try-catch

Utilisez la gestion des erreurs pour gérer les tentatives d'insertion :

try {
  db.books.insertOne({
    title: "1984",
    author: "George Orwell",
    year: 1949,
    genres: ["Dystopian", "Science Fiction"]
  })
} catch (e) {
  print("Error inserting document:", e.message)
}

Cette approche montre une gestion gracieuse des erreurs lors de l'insertion de documents.

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

Dans cette étape finale, nous allons vérifier l'intégrité des données de notre collection MongoDB, en nous assurant que nos documents sont stockés correctement et répondent à nos critères définis.

Compter les documents

Vérifiez le nombre total de documents :

use bookstore
db.books.countDocuments()

Vérifier l'existence d'un document spécifique

Utilisez findOne() pour vérifier un document spécifique :

db.books.findOne({ title: "To Kill a Mockingbird" })

Valider le schéma de la collection

Créez une règle de validation pour garantir la structure des documents :

db.runCommand({
  collMod: "books",
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["title", "author", "year"],
      properties: {
        title: {
          bsonType: "string",
          description: "must be a string and is required"
        },
        author: {
          bsonType: "string",
          description: "must be a string and is required"
        },
        year: {
          bsonType: "int",
          minimum: 1000,
          maximum: 2023,
          description: "must be an integer between 1000 and 2023"
        }
      }
    }
  }
})

Cette étape garantit que nos documents conservent une structure cohérente et valide.

Résumé

Dans ce laboratoire (lab), vous avez appris avec succès à insérer des documents dans MongoDB en utilisant diverses techniques. Vous avez commencé par insérer un seul document, puis vous êtes passé à des insertions en bloc avec plusieurs documents. Vous avez exploré des méthodes pour trouver et récupérer des documents, gérer les erreurs potentielles d'insertion et valider l'intégrité des données à l'aide d'index uniques et de la validation de schéma JSON.

Les compétences clés que vous avez acquises incluent l'utilisation des méthodes insertOne() et insertMany(), la création d'index uniques, la mise en œuvre de stratégies de gestion des erreurs et la vérification des structures de documents. Ces opérations CRUD (Create, Read, Update, Delete) fondamentales fournissent une base solide pour travailler avec MongoDB, vous permettant de gérer et de manipuler efficacement les données dans les bases de données NoSQL.