Hub de Connaissances DevOps
Hub de Connaissances DevOps

Maîtriser les opérations CRUD de MongoDB : un guide pratique des commandes

Libérez la puissance de MongoDB avec ce guide pratique des commandes essentielles pour les opérations CRUD. Apprenez à gérer efficacement vos données en utilisant les commandes `insert`, `find`, `update` et `delete`. Cet article fournit des explications claires, des exemples concrets et des meilleures pratiques pour créer, lire, mettre à jour et supprimer des documents dans vos collections MongoDB. Parfait pour les développeurs et les administrateurs, c'est votre ressource incontournable pour maîtriser la manipulation des données MongoDB.

38 vues

Maîtriser les opérations CRUD de MongoDB : un guide pratique des commandes

MongoDB, une base de données de documents NoSQL populaire, constitue la colonne vertébrale d'innombrables applications modernes en raison de sa flexibilité, de son évolutivité et de ses performances. Au cœur de l'interaction avec n'importe quelle base de données se trouvent les opérations fondamentales de création, lecture, mise à jour et suppression (CRUD). Maîtriser ces commandes est essentiel pour toute personne travaillant avec MongoDB, des développeurs créant de nouvelles fonctionnalités aux administrateurs gérant des données.

Ce guide complet vous présentera les commandes MongoDB essentielles pour effectuer des opérations CRUD. Nous couvrirons les commandes insert, find, update et delete avec des exemples pratiques et faciles à comprendre, vous dotant des connaissances nécessaires pour gérer efficacement vos données. À la fin de cet article, vous aurez une solide compréhension de la manière d'interagir avec vos collections MongoDB de manière efficace et confiante.

Prérequis

Avant de plonger dans les commandes, assurez-vous d'avoir :

  • MongoDB installé et en cours d'exécution : Vous pouvez le télécharger sur le site officiel de MongoDB ou utiliser un service cloud comme MongoDB Atlas.
  • mongosh (MongoDB Shell) installé : C'est l'interface JavaScript interactive pour MongoDB.

Connexion à MongoDB et sélection d'une base de données

Pour commencer, ouvrez votre terminal ou votre invite de commande et connectez-vous à votre instance MongoDB à l'aide de mongosh :

mongosh

Une fois connecté, vous serez dans la base de données test par défaut. Pour passer à une nouvelle base de données ou en créer une, utilisez la commande use :

use myDatabase;

Si myDatabase n'existe pas, MongoDB la créera implicitement lorsque vous insérerez votre premier document dans une collection.

Opérations de création (Insertion)

Les opérations de création impliquent l'ajout de nouveaux documents à une collection. MongoDB fournit des méthodes pour insérer un ou plusieurs documents.

1. db.collection.insertOne()

Cette méthode insère un seul document dans une collection. Si la collection n'existe pas, MongoDB la crée.

// Sélectionner une collection nommée 'users'
db.users.insertOne({
  name: "Alice Smith",
  age: 30,
  city: "New York",
  email: "[email protected]",
  interests: ["reading", "hiking"]
});

La sortie affichera le statut acknowledged et l'insertedId du nouveau document.

2. db.collection.insertMany()

Utilisez cette méthode pour insérer plusieurs documents dans une collection en une seule opération. Elle prend un tableau de documents.

db.users.insertMany([
  {
    name: "Bob Johnson",
    age: 24,
    city: "Los Angeles",
    email: "[email protected]",
    interests: ["coding", "gaming"]
  },
  {
    name: "Charlie Brown",
    age: 35,
    city: "New York",
    email: "[email protected]",
    interests: ["cooking", "photography"]
  },
  {
    name: "Diana Prince",
    age: 29,
    city: "London",
    email: "[email protected]",
    interests: ["fitness", "travel"]
  }
]);

Ceci retournera un tableau d'insertedIds pour tous les documents ajoutés.

Astuce : MongoDB ajoute automatiquement un champ _id (un ObjectId unique) à chaque document si vous n'en fournissez pas.

Opérations de lecture (Recherche)

Les opérations de lecture impliquent l'interrogation de documents à partir d'une collection. La méthode find() est votre principal outil pour cela.

1. db.collection.find()

a. Trouver tous les documents

Pour récupérer tous les documents d'une collection, appelez find() sans arguments :

db.users.find();

b. Trouver des documents avec un filtre de requête

Passez un document de requête à find() pour spécifier les critères de sélection des documents. Cela agit comme une clause WHERE en SQL.

// Trouver les utilisateurs de New York
db.users.find({ city: "New York" });

// Trouver les utilisateurs de plus de 25 ans
db.users.find({ age: { $gt: 25 } });

// Trouver les utilisateurs dont l'âge est compris entre 25 et 35 ans (excluant 35)
db.users.find({ age: { $gt: 25, $lt: 35 } });

// Trouver les utilisateurs dont les intérêts incluent 'coding'
db.users.find({ interests: "coding" });

// Trouver les utilisateurs dont les intérêts incluent À LA FOIS 'reading' et 'hiking'
db.users.find({ interests: { $all: ["reading", "hiking"] } });

// Trouver les utilisateurs nommés Alice Smith OU venant de Londres
db.users.find({
  $or: [
    { name: "Alice Smith" },
    { city: "London" }
  ]
});

Opérateurs de requête courants :
* $eq : Égal à (par défaut si aucun opérateur n'est spécifié)
* $ne : Différent de
* $gt : Supérieur à
* $gte : Supérieur ou égal à
* $lt : Inférieur à
* $lte : Inférieur ou égal à
* $in : Correspond à l'une des valeurs spécifiées dans un tableau
* $nin : Ne correspond à aucune des valeurs spécifiées dans un tableau
* $and, $or, $not, $nor : Opérateurs logiques

c. Projection : Sélection de champs spécifiques

Pour retourner uniquement un sous-ensemble de champs, passez un document de projection comme deuxième argument à find(). Une valeur de 1 inclut le champ, 0 l'exclut. Le champ _id est inclus par défaut sauf exclusion explicite.

// Retourner uniquement le nom et l'e-mail, exclure _id
db.users.find({ city: "New York" }, { name: 1, email: 1, _id: 0 });

d. Tri, Limite et Saut

L'enchaînement des méthodes permet des requêtes plus complexes :

// Trier par âge en ordre décroissant (1 pour croissant, -1 pour décroissant)
db.users.find().sort({ age: -1 });

// Limiter les résultats à 2 documents
db.users.find().limit(2);

// Sauter les 2 premiers documents et retourner le reste
db.users.find().skip(2);

// Combiner les opérations : Trouver les utilisateurs de New York, trier par âge, sauter 1, limiter à 1
db.users.find({ city: "New York" }).sort({ age: 1 }).skip(1).limit(1);

2. db.collection.findOne()

Cette méthode retourne un seul document qui correspond aux critères de la requête. Si plusieurs documents correspondent, elle retourne le premier trouvé.

db.users.findOne({ name: "Alice Smith" });

Opérations de mise à jour

Les opérations de mise à jour modifient les documents existants dans une collection. Vous pouvez mettre à jour un seul document, plusieurs documents, ou même remplacer un document entier.

1. db.collection.updateOne()

Met à jour un seul document qui correspond aux critères du filtre.

// Mettre à jour la ville d'Alice à 'San Francisco'
db.users.updateOne(
  { name: "Alice Smith" },
  { $set: { city: "San Francisco", lastUpdated: new Date() } }
);

2. db.collection.updateMany()

Met à jour tous les documents qui correspondent aux critères du filtre.

// Incrémenter l'âge de tous les utilisateurs de New York de 1
db.users.updateMany(
  { city: "New York" },
  { $inc: { age: 1 } }
);

// Ajouter un nouvel intérêt 'reading' aux utilisateurs qui ne l'ont pas déjà
db.users.updateMany(
  {}, // Appliquer à tous les documents
  { $addToSet: { interests: "reading" } }
);

// Supprimer 'gaming' des intérêts de Bob Johnson
db.users.updateOne(
  { name: "Bob Johnson" },
  { $pull: { interests: "gaming" } }
);

Opérateurs de mise à jour courants :
* $set : Définit la valeur d'un champ dans un document. Crée le champ s'il n'existe pas.
* $inc : Incrémente la valeur d'un champ d'un montant spécifié.
* $unset : Supprime un champ d'un document.
* $push : Ajoute une valeur à un champ de type tableau.
* $pull : Supprime toutes les occurrences d'une valeur ou de valeurs correspondant à une requête spécifiée d'un tableau.
* $addToSet : Ajoute une valeur à un tableau uniquement si la valeur n'est pas déjà présente.

3. db.collection.replaceOne()

Remplace un seul document qui correspond aux critères du filtre par un nouveau document. Le champ _id du document remplacé ne peut pas être modifié.

// Remplacer entièrement le document de Bob Johnson
db.users.replaceOne(
  { name: "Bob Johnson" },
  {
    name: "Robert Johnson",
    occupation: "Software Engineer",
    status: "active",
    email: "[email protected]"
  }
);

Option Upsert

Les méthodes updateOne() et updateMany() prennent en charge une option upsert. Si elle est définie sur true, et qu'aucun document ne correspond au filtre, MongoDB insérera un nouveau document basé sur la requête et les opérations de mise à jour.

db.users.updateOne(
  { name: "David Lee" },
  { $set: { age: 28, city: "Seattle" } },
  { upsert: true } // Si David Lee n'existe pas, créez-le
);

Opérations de suppression

Les opérations de suppression suppriment des documents d'une collection. Soyez extrêmement prudent avec les opérations de suppression, car elles sont irréversibles.

1. db.collection.deleteOne()

Supprime au plus un document qui correspond au filtre spécifié.

// Supprimer l'utilisateur nommé 'Robert Johnson' (anciennement 'Bob Johnson')
db.users.deleteOne({ name: "Robert Johnson" });

2. db.collection.deleteMany()

Supprime tous les documents qui correspondent au filtre spécifié.

// Supprimer tous les utilisateurs de Londres
db.users.deleteMany({ city: "London" });

Avertissement : Pour supprimer tous les documents d'une collection, utilisez un filtre vide {}. Soyez extrêmement prudent car cette opération ne peut pas être annulée :

javascript db.users.deleteMany({}); // Supprime tous les documents de la collection 'users'

3. db.collection.drop()

Cette méthode supprime définitivement une collection entière de la base de données, y compris tous ses documents et index.

db.users.drop(); // Supprime la collection 'users' entière

Avertissement : La suppression d'une collection est une opération très destructrice. Assurez-vous d'avoir des sauvegardes appropriées ou d'être absolument certain avant d'exécuter cette commande.

Bonnes pratiques pour les opérations CRUD de MongoDB

  • Indexation : Pour les champs fréquemment interrogés, créez des index pour accélérer considérablement les opérations de lecture. db.collection.createIndex({ fieldName: 1 }).
  • Projections : Récupérez uniquement les données dont vous avez besoin. L'utilisation de projections ({ field: 1 }) réduit la bande passante réseau et l'utilisation de la mémoire.
  • Opérations par lots : Lors de l'insertion, de la mise à jour ou de la suppression de nombreux documents, utilisez insertMany(), updateMany() et deleteMany() au lieu d'opérations individuelles pour réduire la surcharge.
  • Comprendre les opérateurs : Familiarisez-vous avec le riche ensemble d'opérateurs de requête et de mise à jour de MongoDB. Ils offrent des moyens puissants de manipuler vos données.
  • Gestion des erreurs : Dans une application de production, implémentez toujours une gestion robuste des erreurs pour vos opérations de base de données.
  • Conception du schéma : Bien que MongoDB soit sans schéma, une conception réfléchie du schéma est cruciale pour des requêtes efficaces et la cohérence des données.

Conclusion

Maîtriser les opérations CRUD de MongoDB est fondamental pour une gestion efficace des données et le développement d'applications. Ce guide vous a présenté un aperçu pratique des commandes essentielles insert, find, update et delete, complété par des exemples et des bonnes pratiques.

En comprenant comment créer, lire, mettre à jour et supprimer des documents, vous avez acquis les compétences de base pour interagir efficacement avec vos bases de données MongoDB. Continuez à pratiquer ces commandes et explorez des fonctionnalités plus avancées comme les pipelines d'agrégation, les transactions et les stratégies d'indexation pour améliorer davantage votre expertise MongoDB.