MongoDB
 sql >> Base de données >  >> NoSQL >> MongoDB

Comment gérer des documents dans MongoDB


Introduction

Lorsque vous utilisez MongoDB, vous passerez la plupart de votre temps à gérer des documents d'une manière ou d'une autre. Que vous créiez de nouveaux documents et les ajoutiez à des collections, récupériez des documents, mettiez à jour des données ou supprimiez des éléments obsolètes, les documents sont au centre du modèle MongoDB.

Dans ce guide, nous couvrirons les documents MongoDB, puis les opérations courantes que vous devrez probablement connaître pour gérer un environnement centré sur les documents.



Que sont les documents MongoDB ?

Dans MongoDB, toutes les données des bases de données et des collections sont stockées dans des documents. Étant donné que les collections ne spécifient pas de schéma requis par défaut, les documents d'une collection peuvent contenir une structure arbitrairement complexe et n'ont pas besoin de correspondre au format utilisé par les documents frères. Cela offre une flexibilité incroyable et permet au schéma de se développer de manière organique à mesure que les exigences de l'application changent.

Les documents MongoDB eux-mêmes utilisent le format de sérialisation des données BSON, une représentation binaire de la notation d'objet JavaScript JSON. Cela fournit une structure organisée avec des types de données définis qui peuvent être interrogés et exploités par programmation.

Les documents BSON sont représentés par une paire d'accolades ({} ) qui contiennent des paires clé-valeur. Dans BSON, ces couplets de données sont connus sous le nom de champ et sa valeur . Le champ vient en premier et est représenté par une chaîne. La valeur peut être n'importe quel type de données BSON valide. Deux-points (: ) sépare le champ de sa valeur. Une virgule est utilisée pour séparer chaque champ et paire de valeurs les uns des autres.

À titre d'exemple, voici un document BSON valide que MongoDB peut comprendre :

{    _id: 80380,    vehicle_type: "car",    mileage: 7377.80,    color: "blue",    markets: [        "US",        "UK"    ],    options: {        transmission: "automatic",        num_doors: 4,        power_windows: true    }}

Ici, nous pouvons voir plusieurs types :

  • _id est un entier
  • vehicle_type et color sont des chaînes
  • mileage est un flottant
  • markets est un tableau de chaînes
  • options contient un document imbriqué avec des valeurs composées d'une chaîne, d'un entier et d'un booléen

En raison de cette flexibilité, les documents sont un support assez flexible pour stocker des données. De nouveaux champs peuvent être ajoutés facilement, les documents peuvent être intégrés les uns dans les autres et la complexité structurelle correspond exactement aux données stockées.



Comment créer de nouveaux documents

Pour créer un nouveau document, passez à une base de données dans laquelle vous souhaitez stocker le document créé. Nous utiliserons une school base de données à des fins de démonstration dans cet article :

use school

Vous devrez également choisir la collection dans laquelle vous souhaitez insérer les documents. Comme pour les bases de données, vous n'avez pas à créer explicitement la collection dans laquelle vous souhaitez insérer le document. MongoDB le créera automatiquement lorsque les premières données seront écrites. Pour cet exemple, nous utiliserons une collection appelée students .

Maintenant que vous savez où le document sera stocké, vous pouvez insérer un nouveau document en utilisant l'une des méthodes suivantes.


Utilisation de insert() méthode

Le insert() permet d'insérer un ou plusieurs documents dans la collection sur laquelle elle est appelée.

Pour insérer un seul document, passez le document à la méthode en l'appelant sur la collection. Ici, nous insérons un nouveau document pour un étudiant nommé Ashley :

db.students.insert(    {        first_name: "Ashley",        last_name: "Jenkins",        dob: new Date("January 08, 2003"),        grade_level: 8    })
 
WriteResult({ "nInserted" : 1 })

Si vous souhaitez insérer plusieurs documents en même temps, au lieu de passer un document à insert() , passez un tableau de documents. Nous pouvons ajouter deux nouveaux documents pour les étudiants nommés Brian et Leah :

db.students.insert(    [        {            first_name: "Brian",            last_name: "McMantis",            dob: new Date("September 18, 2010"),            grade_level: 2        },        {            first_name: "Leah",            last_name: "Drake",            dob: new Date("October 03, 2009")        }    ])
 
BulkWriteResult({        "writeErrors" : [ ],        "writeConcernErrors" : [ ],        "nInserted" : 2,        "nUpserted" : 0,        "nMatched" : 0,        "nModified" : 0,        "nRemoved" : 0,        "upserted" : [ ]})

Puisque nous avons effectué une opération d'écriture en bloc, notre valeur de retour est un BulkWriteResult au lieu de WriteResult objet que nous avons déjà vu.

Alors que le insert() est flexible, elle a été dépréciée dans de nombreux pilotes MongoDB au profit des deux méthodes suivantes.



Utilisation de insertOne() méthode

Le insertOne() peut être utilisée pour insérer un seul document. Contrairement à insert() méthode, il ne peut insérer qu'un seul document à la fois, ce qui rend son comportement un peu plus prévisible.

La syntaxe est la même que lorsque vous utilisez insert() pour ajouter un seul document. Nous pouvons ajouter une autre étudiante nommée Naomi :

db.students.insertOne(    {        first_name: "Naomi",        last_name: "Pyani"    })
 
{        "acknowledged" : true,        "insertedId" : ObjectId("60e877914655cbf49ff7cb86")}

Contrairement à insert() , le insertOne() La méthode renvoie un document contenant des informations utiles supplémentaires. Il confirme que l'écriture a été reconnue par le cluster et inclut l'ID d'objet qui a été attribué au document puisque nous n'en avons pas fourni.



Utilisation de insertMany() méthode

Pour couvrir les scénarios où vous souhaitez insérer plusieurs documents à la fois, le insertMany() méthode est maintenant recommandée. Tout comme lors de l'insertion de plusieurs documents avec insert() , insertMany() prend un tableau de documents.

Nous pouvons ajouter trois nouveaux étudiants nommés Jasmine, Michael et Toni :

db.students.insertMany(    [        {            first_name: "Jasmine",            last_name: "Took",            dob: new Date("April 11, 2011")        },        {            first_name: "Michael",            last_name: "Rodgers",            dob: new Date("February 25, 2008"),            grade_level: 6        },        {            first_name: "Toni",            last_name: "Fowler"        }    ])
 
{        "acknowledged" : true,        "insertedIds" : [                ObjectId("60e8792d4655cbf49ff7cb87"),                ObjectId("60e8792d4655cbf49ff7cb88"),                ObjectId("60e8792d4655cbf49ff7cb89")        ]}

Comme avec insertOne() , insertMany() renvoie un document qui accuse réception de l'écriture et fournit un tableau contenant les ID qui ont été attribués aux documents insérés.




Comment interroger des documents existants

L'interrogation de documents est un sujet assez vaste qui mérite son propre article. Vous pouvez trouver des détails sur la façon de formuler des requêtes pour récupérer différents types de documents dans notre guide sur l'interrogation des données dans MongoDB.

Bien qu'il soit préférable de laisser les détails dans l'article lié ci-dessus, nous pouvons au moins couvrir les méthodes fournies par MongoDB pour interroger les documents. Le principal moyen de récupérer des documents à partir de MongoDB est d'appeler le find() méthode sur la collection en question.

Par exemple, pour collecter tous les documents des students , vous pouvez appeler find() sans argument :

db.students.find()
 
{ "_id" : ObjectId("60e8743b4655cbf49ff7cb83"), "first_name" : "Ashley", "last_name" : "Jenkins", "dob" : ISODate("2003-01-08T00:00:00Z"), "grade_level" : 8 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb84"), "first_name" : "Brian", "last_name" : "McMantis", "dob" : ISODate("2010-09-18T00:00:00Z"), "grade_level" : 2 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb85"), "first_name" : "Leah", "last_name" : "Drake", "dob" : ISODate("2009-10-03T00:00:00Z") }{ "_id" : ObjectId("60e877914655cbf49ff7cb86"), "first_name" : "Naomi", "last_name" : "Pyani" }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb87"), "first_name" : "Jasmine", "last_name" : "Took", "dob" : ISODate("2011-04-11T00:00:00Z") }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb88"), "first_name" : "Michael", "last_name" : "Rodgers", "dob" : ISODate("2008-02-25T00:00:00Z"), "grade_level" : 6 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler" }

Pour rendre la sortie plus lisible, vous pouvez également chaîner le pretty() méthode après find() :

db.<collection>.find().pretty()
 
{        "_id" : ObjectId("60e8743b4655cbf49ff7cb83"),        "first_name" : "Ashley",        "last_name" : "Jenkins",        "dob" : ISODate("2003-01-08T00:00:00Z"),        "grade_level" : 8}{        "_id" : ObjectId("60e875d54655cbf49ff7cb84"),        "first_name" : "Brian",        "last_name" : "McMantis",        "dob" : ISODate("2010-09-18T00:00:00Z"),        "grade_level" : 2}{        "_id" : ObjectId("60e875d54655cbf49ff7cb85"),        "first_name" : "Leah",        "last_name" : "Drake",        "dob" : ISODate("2009-10-03T00:00:00Z")}{        "_id" : ObjectId("60e877914655cbf49ff7cb86"),        "first_name" : "Naomi",        "last_name" : "Pyani"}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb87"),        "first_name" : "Jasmine",        "last_name" : "Took",        "dob" : ISODate("2011-04-11T00:00:00Z")}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb88"),        "first_name" : "Michael",        "last_name" : "Rodgers",        "dob" : ISODate("2008-02-25T00:00:00Z"),       "grade_level" : 6}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb89"),        "first_name" : "Toni",        "last_name" : "Fowler"}

Vous pouvez voir qu'un _id champ a été ajouté à chacun des documents. MongoDB nécessite un _id unique pour chaque document d'une collection. Si vous n'en fournissez pas lors de la création de l'objet, il en ajoutera un pour vous. Vous pouvez utiliser cet ID pour récupérer un seul objet de manière fiable :

db.students.find(    {        _id : ObjectId("60e8792d4655cbf49ff7cb89")    })
 
{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler" }

Vous pouvez en savoir plus sur les différentes manières d'interroger les données avec l'article lié ci-dessus.



Comment mettre à jour des documents existants

De nombreux ou la plupart des cas d'utilisation des bases de données nécessitent que vous puissiez modifier les données existantes dans la base de données. Un champ peut devoir être mis à jour pour refléter une nouvelle valeur ou vous pouvez avoir besoin d'ajouter des informations supplémentaires à un document existant dès qu'il devient disponible.

MongoDB utilise quelques méthodes connexes pour mettre à jour les documents existants :

  • updateOne()  :met à jour un seul document dans une collection en fonction du filtre fourni.
  • updateMany()  :met à jour plusieurs documents d'une collection qui correspondent au filtre fourni.
  • replaceOne()  :Remplace un document entier dans une collection en fonction du filtre fourni.

Nous expliquerons comment utiliser chacune de ces variétés pour effectuer différents types de mises à jour.


Opérateurs de mise à jour

Avant d'examiner chacune des méthodes de mise à jour des documents, nous devons passer en revue certains des opérateurs de mise à jour disponibles.

  • $currentDate :définit la valeur d'un champ sur la date actuelle, sous forme de date ou d'horodatage.
    • Syntaxe :{ $currentDate: { <field>: <type>, ... } }
  • $inc :Incrémente la valeur d'un champ d'un montant défini.
    • Syntaxe :{ $inc: { <field>: <amount>, ... } }
  • $min :met à jour la valeur d'un champ si la valeur spécifiée est inférieure à la valeur actuelle.
    • Syntaxe :{ $min: { <field>: <value>, ... } }
  • $max :met à jour la valeur d'un champ si la valeur spécifiée est supérieure à la valeur actuelle.
    • Syntaxe :{ $max: { <field>: <value>, ... } }
  • $mul :Met à jour la valeur d'un champ en la multipliant par le nombre donné.
    • Syntaxe :{ $mul: { <field>: <value>, ... } }
  • $rename :Renomme un nom de champ en un nouvel identifiant.
    • Syntaxe :{ $rename: { <field>: <new_name>, ... } }
  • $set :Remplace la valeur d'un champ par la valeur donnée.
    • Syntaxe :{ $set: { <field>: value, ... } }
  • $setOnInsert :Lors des opérations d'upsert, définit la valeur d'un champ si un nouveau document est en cours de création et ne fait rien autrement.
    • Syntaxe :{ $setOnInsert: { <field>: <value>, ... } }
  • $unset :Supprime un champ du document.
    • Syntaxe :{ $unset: { <field>: "", ... } }
  • $ :Un espace réservé pour le premier élément du tableau qui satisfait la requête.
    • Syntaxe :{ <update_operator>: {<array>.$: <value> } }
  • $[] :Un espace réservé pour tous les éléments du tableau qui satisfont la requête.
    • Syntaxe :{ <update_operator>: { <array>.$[]: <value> } }
  • $addToSet :Ajoute des valeurs au tableau à moins qu'elles ne soient déjà présentes.
    • Syntaxe :{ $addToSet: { <field>: <value>, ... } }
  • $pop :Supprime le premier ou le dernier élément d'un tableau.
    • Syntaxe :{ $pop: { <field>: (-1 or 1), ... } }
  • $pull :Supprime tous les éléments d'un tableau qui correspondent à une condition.
    • Syntaxe :{ $pull: { <field>: <condition>, ... } }
  • $push :Ajoute une valeur à un tableau.
    • Syntaxe :{ $push: { <field>: <value>, ... } }
  • $pullAll :Supprime tous les éléments spécifiés d'un tableau.
    • Syntaxe :{ $pullAll: { <field>: [ <value>, ... ], ...} }
  • $each :Modifie $addToSet et $push opérateurs afin qu'ils ajoutent chaque élément d'un tableau au lieu d'un tableau comme un seul élément.
    • Syntaxe :{ <update_operator>: { <field>: { $each: [ <value>, ... ] }, ... } }
  • $position :Utilisé avec $each et précise la position du $push l'opérateur doit insérer at.
    • Syntaxe :{ $push: { <field>: { $each: [ <value>, ... ], $position: <num> } } }
  • $slice :Utilisé avec $each et $push pour limiter le nombre total d'éléments dans le tableau.
    • Syntaxe :{ $push: { <field>: { $each: [ <value>, ... ], $slice: <num> } } }
  • $sort :Utilisé avec $each et $push pour trier les éléments du tableau.
    • Syntaxe :{ $push: { <field>: { $each: [ <value>, ... ], $sort: <sort_order> } } }

Ces différents opérateurs de mise à jour vous permettent de mettre à jour différents champs de vos documents de différentes manières.



Mise à jour d'un seul document dans une collection

updateOne() de MongoDB La méthode est utilisée pour mettre à jour un seul document dans une collection. La méthode prend deux arguments obligatoires ainsi qu'un document spécifiant des arguments optionnels.

Le premier argument est un document qui spécifie les conditions de filtre qui seront utilisées pour sélectionner les documents. Depuis le updateOne() Si la méthode modifie au plus un document d'une collection, le premier document qui satisfait les conditions du filtre sera utilisé.

Le deuxième argument spécifie l'opération de mise à jour qui doit être exécutée. Les opérations de mise à jour indiquées ci-dessus peuvent être spécifiées ici pour modifier le contenu du document correspondant.

Le troisième argument est un document de diverses options pour modifier le comportement de la méthode. Les valeurs potentielles les plus importantes sont :

  • upsert  :Transforme l'opération en une procédure d'upsert en insérant un nouveau document si le filtre ne correspond à aucun document existant.
  • collation  :Un document qui définit les règles spécifiques à la langue qui doivent s'appliquer à l'opération.

Par exemple, nous pouvons mettre à jour un seul enregistrement d'étudiant que nous filtrons par le _id pour nous assurer que nous ciblons le bon document. Nous pouvons définir le grade_level à une nouvelle valeur :

db.students.updateOne(    { _id: ObjectId("60e8792d4655cbf49ff7cb89") },    { $set: { grade_level: 3 } })
 
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }


Mise à jour de plusieurs documents dans une collection

updateMany() de MongoDB la méthode fonctionne de la même manière que updateOne() méthode, mais met à jour à la place tout document qui correspond au filtre donné au lieu de s'arrêter après la première correspondance.

Le updateMany() la syntaxe suit exactement le updateOne() syntaxe, donc la seule différence est la portée de l'opération.

Par exemple, si nous voulons changer toutes les instances de "composition" en "écriture" dans les subjects tableau dans nos teachers documents de collection, nous pourrions utiliser quelque chose comme ceci :

db.teachers.updateMany(    { subject: "composition" },    { $set: { "subjects.$": "writing" } })
 
{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }

Si vous vérifiez les documents, chaque occurrence de "composition" aurait dû être remplacée par "écriture":

db.teachers.find()
 
{ "_id" : ObjectId("60eddca65eb74f5c676f3baa"), "first_name" : "Nancy", "last_name" : "Smith", "subjects" : [ "vocabulary", "pronunciation" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bab"), "first_name" : "Ronald", "last_name" : "Taft", "subjects" : [ "literature", "grammar", "writing" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bac"), "first_name" : "Casey", "last_name" : "Meyers", "subjects" : [ "literature", "writing", "grammar" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bad"), "first_name" : "Rebecca", "last_name" : "Carrie", "subjects" : [ "grammar", "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bae"), "first_name" : "Sophie", "last_name" : "Daggs", "subjects" : [ "literature", "writing", "grammar", "vocabulary", "pronunciation" ] }


Remplacer un document

Le replaceOne() la méthode fonctionne de la même manière que updateOne() méthode, mais remplace le document entier au lieu de mettre à jour des champs individuels. La syntaxe est la même que les deux commandes précédentes.

Par exemple, si Nancy Smith quitte votre école et que vous la remplacez par une enseignante nommée Clara Newman qui enseigne la littérature, vous pouvez taper ce qui suit :

db.teachers.replaceOne(    {        $and: [             { first_name: "Nancy" },            { last_name: "Smith" }        ]    },    {        first_name: "Clara",        last_name: "Newman",        subjects: [ "literature" ]    })
 
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

Vous pouvez voir que le document correspondant a été supprimé et que le document spécifié l'a remplacé :

db.teachers.find()
 
{ "_id" : ObjectId("60eddca65eb74f5c676f3baa"), "first_name" : "Clara", "last_name" : "Newman", "subjects" : [ "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bab"), "first_name" : "Ronald", "last_name" : "Taft", "subjects" : [ "literature", "grammar", "writing" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bac"), "first_name" : "Casey", "last_name" : "Meyers", "subjects" : [ "literature", "writing", "grammar" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bad"), "first_name" : "Rebecca", "last_name" : "Carrie", "subjects" : [ "grammar", "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bae"), "first_name" : "Sophie", "last_name" : "Daggs", "subjects" : [ "literature", "writing", "grammar", "vocabulary", "pronunciation" ] }



Comment supprimer des documents

La suppression de documents des collections fait également partie du cycle de vie des documents. Pour supprimer un document, vous pouvez utiliser le deleteOne() ou deleteMany() méthodes. Ils ont la même syntaxe et ne diffèrent que par le nombre de documents sur lesquels ils opèrent.

Dans la plupart des cas, tout ce que vous avez à faire pour supprimer des documents avec l'une ou l'autre de ces méthodes est de lui fournir un document filtre qui spécifie comment vous souhaitez sélectionner le document à supprimer. Le deleteOne() supprimera au plus un document (quel que soit le nombre de correspondances produites par le filtre) tandis que la méthode deleteMany() supprime tous les documents qui correspondent aux conditions du filtre.

Par exemple, pour supprimer un seul étudiant, vous pouvez fournir un _id pour les faire correspondre explicitement :

db.students.deleteOne({    _id: ObjectId("60e8792d4655cbf49ff7cb87")})
 
{ "acknowledged" : true, "deletedCount" : 1 }

Si nous voulons supprimer un étudiant qui n'a pas de niveau scolaire attribué, nous pouvons utiliser le deleteMany() méthode à la place :

db.students.deleteMany({    grade_level: { $eq: null }})
 
{ "acknowledged" : true, "deletedCount" : 2 }

Si nous vérifions, nous devrions voir que tous les élèves restants ont un niveau scolaire :

db.students.find()
 
{ "_id" : ObjectId("60e8743b4655cbf49ff7cb83"), "first_name" : "Ashley", "last_name" : "Jenkins", "dob" : ISODate("2003-01-08T00:00:00Z"), "grade_level" : 8 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb84"), "first_name" : "Brian", "last_name" : "McMantis", "dob" : ISODate("2010-09-18T00:00:00Z"), "grade_level" : 2 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb88"), "first_name" : "Michael", "last_name" : "Rodgers", "dob" : ISODate("2008-02-25T00:00:00Z"), "grade_level" : 6 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler", "grade_level" : 3 }


Conclusion

Apprendre à créer, interroger, mettre à jour et supprimer des documents vous donne les compétences dont vous avez besoin pour gérer efficacement les documents au sein de MongoDB au quotidien. Se familiariser avec les différentes méthodes de documentation et de collecte et les opérateurs qui permettent de faire correspondre et de modifier les informations permet d'exprimer des pensées complexes que le système de base de données peut comprendre.