Opérations CRUD (Create, Read, Update, Delete)

Les opérations CRUD représentent les quatre opérations de base utilisées pour interagir avec les données dans une base de données. Dans le contexte de MongoDB, voici comment vous pouvez effectuer des opérations CRUD en utilisant le pilote MongoDB natif ou Mongoose dans Node.js.

Avec le Pilote MongoDB Natif

1. Create (Créer): Pour insérer des données, utilisez insertOne() pour un document ou insertMany() pour plusieurs documents.

const { MongoClient } = require('mongodb');
const url = 'mongodb://localhost:27017';
const dbName = 'mydatabase';
const client = new MongoClient(url);

async function createData() {
  try {
    await client.connect();
    console.log('Connecté à MongoDB');
    const db = client.db(dbName);
    const collection = db.collection('documents');

    // Insertion d'un seul document
    const insertResult = await collection.insertOne({ a: 1 });
    console.log('Résultat de l\'insertion:', insertResult);

    // Insertion de plusieurs documents
// Attention au crochets; bug d'affichages il faut ajouter des crochets dans le json
    const multipleInsertResult = await collection.insertMany( [ { b: 1 }, { b: 2 }] );

    console.log('Résultat de l\'insertion multiple:', multipleInsertResult);
  } finally {
    await client.close();
  }
}

createData();

1. Read (Lire): Utilisez find() pour récupérer plusieurs documents ou findOne() pour un seul document.

   async function readData() {
     try {
       await client.connect();
       const db = client.db(dbName);
       const collection = db.collection('documents');
   
       // Trouver un seul document
       const item = await collection.findOne({ a: 1 });
       console.log('Document trouvé:', item);
   
       // Trouver plusieurs documents
       const items = await collection.find({}).toArray();
       console.log('Documents trouvés:', items);
     } finally {
       await client.close();
     }
   }
   
   readData();
   

    

2. Update (Mettre à jour): Pour mettre à jour des documents, utilisez updateOne(), updateMany(), ou findOneAndUpdate().

   async function updateData() {
     try {
       await client.connect();
       const db = client.db(dbName);
       const collection = db.collection('documents');
   
       // Mettre à jour un seul document
       const updateResult = await collection.updateOne({ a: 1 }, { $set: { b: 1 } });
       console.log('Résultat de la mise à jour:', updateResult);
   
       // Mettre à jour plusieurs documents
       const multipleUpdateResult = await collection.updateMany({}, { $set: { b: 1 } });
       console.log('Résultat de la mise à jour multiple:', multipleUpdateResult);
     } finally {
       await client.close();
     }
   }
   
   updateData();
   

3. Delete (Supprimer): Pour supprimer des documents, utilisez deleteOne() ou deleteMany().

   async function deleteData() {
     try {
       await client.connect();
       const db = client.db(dbName);
       const collection = db.collection('documents');
   
       // Supprimer un seul document
       const deleteResult = await collection.deleteOne({ a: 1 });
       console.log('Résultat de la suppression:', deleteResult);
   
       // Supprimer plusieurs documents
       const multipleDeleteResult = await collection.deleteMany({ b: 1 });
       console.log('Résultat de la suppression multiple:', multipleDeleteResult);
     } finally {
       await client.close();
     }
   }
   
   deleteData();
   

Avec Mongoose

1. Create (Créer): Avec Mongoose, vous définissez d'abord un schéma et un modèle, puis utilisez new Model() ou Model.create().

   const mongoose = require('mongoose');
   
   // URL de connexion à votre base de données MongoDB
   const mongoDBUrl = 'mongodb://localhost:27017/nomnouvellebase';
   
   mongoose.connect(mongoDBUrl);
   
   const db = mongoose.connection;
   db.on('error', console.error.bind(console, 'Erreur de connexion MongoDB:'));
   db.once('open', function() {
     console.log("Connecté à la base de données MongoDB");
   });
   
   // Votre code pour les schémas et modèles ici
   const { Schema } = mongoose;
   
   const userSchema = new Schema({ name: String, age: Number });
   const User = mongoose.model('User', userSchema);
   
   // Créer un nouvel utilisateur
   const newUser = new User({ name: 'John Doe', age: 30 });
   newUser.save().then(doc => console.log('Nouvel utilisateur créé:', doc));
   
   // Créer plusieurs utilisateurs
   User.create([{ name: 'Alice' }, { name: 'Bob' }]).then(doc => console.log('Utilisateurs créés:', doc));
   

2. Read (Lire): Utilisez Model.find(), Model.findOne(), ou Model.findById() pour lire des documents.

   // Trouver tous les utilisateurs
   User.find().then(docs => console.log('Tous les utilisateurs:', docs));
   
   // Trouver un utilisateur par nom
   User.findOne({ name: 'John Doe' }).then(doc => console.log('Utilisateur trouvé:', doc));
   

3. Update (Mettre à jour): Utilisez Model.updateOne(), Model.updateMany(), ou Model.findOneAndUpdate().

   // Mettre à jour un utilisateur
   User.updateOne({ name: 'John Doe' }, { $set: { age: 31 } }).then(result => console.log('Résultat de la mise à jour:', result));
   
   // Mettre à jour plusieurs utilisateurs
   User.updateMany({}, { $set: { age: 30 } }).then(result => console.log('Résultat de la mise à jour multiple:', result));
   

4. Delete (Supprimer): Utilisez Model.deleteOne(), Model.deleteMany(), ou Model.findOneAndDelete().

    

   // Supprimer un utilisateur
   User.deleteOne({ name: 'John Doe' }).then(result => console.log('Résultat de la suppression:', result));
   
   // Supprimer plusieurs utilisateurs
   User.deleteMany({ age: 30 }).then(result => console.log('Résultat de la suppression multiple:', result));
   

En utilisant ces méthodes, vous pouvez facilement effectuer des opérations CRUD sur votre base de données MongoDB à partir d'une application Node.js. Assurez-vous de gérer correctement les connexions et de traiter les erreurs dans votre code de production pour maintenir la robustesse de votre application.