So verwalten Sie Dokumente in MongoDB

Einführung

Wenn Sie MongoDB verwenden, verbringen Sie die meiste Zeit damit, Dokumente auf die eine oder andere Weise zu verwalten. Ganz gleich, ob Sie neue Dokumente erstellen und zu Sammlungen hinzufügen, Dokumente abrufen, Daten aktualisieren oder veraltete Elemente bereinigen, Dokumente stehen im Mittelpunkt des MongoDB-Modells.

In diesem Leitfaden behandeln wir, was MongoDB-Dokumente sind, und behandeln dann die allgemeinen Vorgänge, über die Sie wahrscheinlich Bescheid wissen müssen, um eine dokumentenzentrierte Umgebung zu verwalten.

Was sind MongoDB-Dokumente?

In MongoDB werden alle Daten in Datenbanken und Sammlungen in Dokumenten gespeichert. Da Sammlungen standardmäßig kein erforderliches Schema angeben, können Dokumente innerhalb einer Sammlung eine beliebig komplexe Struktur enthalten und müssen nicht dem Format entsprechen, das von Geschwisterdokumenten verwendet wird. Dies bietet eine unglaubliche Flexibilität und ermöglicht eine organische Entwicklung des Schemas, wenn sich die Anwendungsanforderungen ändern.

MongoDB-Dokumente selbst verwenden das BSON-Datenserialisierungsformat, eine binäre Darstellung der JSON JavaScript Object Notation. Dies bietet eine organisierte Struktur mit definierten Datentypen, die abgefragt und programmgesteuert verarbeitet werden können.

BSON-Dokumente werden durch ein Paar geschweifter Klammern dargestellt ({} ), die Schlüssel-Wert-Paare enthalten. In BSON sind diese Datenpaare als Feld bekannt und seinen Wert . Das Feld steht an erster Stelle und wird durch eine Zeichenfolge dargestellt. Der Wert kann ein beliebiger gültiger BSON-Datentyp sein. Ein Doppelpunkt (: ) trennt das Feld von seinem Wert. Ein Komma wird verwendet, um jedes Feld- und Wertepaar voneinander zu trennen.

Als Beispiel ist hier ein gültiges BSON-Dokument, das MongoDB verstehen kann:

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

Hier sehen wir einige Typen:

• _id ist eine ganze Zahl
• vehicle_type und color sind Zeichenfolgen
• mileage ist ein Float
• markets ist ein Array von Strings
• options enthält ein verschachteltes Dokument mit Werten, die aus einer Zeichenfolge, einer Ganzzahl und einem booleschen Wert bestehen

Aufgrund dieser Flexibilität sind Dokumente ein ziemlich flexibles Medium zum Speichern von Daten. Neue Felder lassen sich einfach hinzufügen, Dokumente können ineinander eingebettet werden und die strukturelle Komplexität passt genau zu den zu speichernden Daten.

Wie man neue Dokumente erstellt

Um ein neues Dokument zu erstellen, wechseln Sie zu einer Datenbank, in der Sie das erstellte Dokument speichern möchten. Wir verwenden eine school Datenbank zu Demonstrationszwecken in diesem Artikel:

use school
 

Sie sollten auch die Sammlung auswählen, in die Sie die Dokumente einfügen möchten. Wie bei Datenbanken müssen Sie die Sammlung, in die Sie das Dokument einfügen möchten, nicht explizit erstellen. MongoDB erstellt es automatisch, wenn die ersten Daten geschrieben werden. Für dieses Beispiel verwenden wir eine Sammlung namens students .

Da Sie nun wissen, wo das Dokument gespeichert wird, können Sie mit einer der folgenden Methoden ein neues Dokument einfügen.

Verwendung von insert() Methode

Das insert() -Methode können Sie ein oder mehrere Dokumente in die Sammlung einfügen, für die sie aufgerufen wird.

Um ein einzelnes Dokument einzufügen, übergeben Sie das Dokument an die Methode, indem Sie es für die Sammlung aufrufen. Hier fügen wir ein neues Dokument für eine Studentin namens Ashley ein:

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

WriteResult({ "nInserted" : 1 })
 

Wenn Sie mehr als ein Dokument gleichzeitig einfügen möchten, anstatt ein Dokument an insert() zu übergeben , übergeben Sie eine Reihe von Dokumenten. Wir können zwei neue Dokumente für Studenten namens Brian und Leah hinzufügen:

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" : [ ]})
 

Da wir einen Massenschreibvorgang durchgeführt haben, ist unser Rückgabewert ein BulkWriteResult anstelle von WriteResult Objekt, das wir zuvor gesehen haben.

Während insert() -Methode flexibel ist, wurde sie in vielen MongoDB-Treibern zugunsten der folgenden beiden Methoden als veraltet markiert.

Verwendung von insertOne() Methode

Die insertOne() Methode kann verwendet werden, um ein einzelnes Dokument einzufügen. Im Gegensatz zu insert() Methode kann nur ein Dokument auf einmal eingefügt werden, was sein Verhalten etwas vorhersehbarer macht.

Die Syntax ist dieselbe wie bei der Verwendung von insert() um ein einzelnes Dokument hinzuzufügen. Wir können eine weitere Schülerin namens Naomi hinzufügen:

db.students.insertOne(    {        first_name: "Naomi",        last_name: "Pyani"    })
 

{        "acknowledged" : true,        "insertedId" : ObjectId("60e877914655cbf49ff7cb86")}
 

Anders bei insert() , das insertOne() -Methode gibt ein Dokument zurück, das einige zusätzliche nützliche Informationen enthält. Es bestätigt, dass der Schreibvorgang vom Cluster bestätigt wurde, und enthält die Objekt-ID, die dem Dokument zugewiesen wurde, da wir keine bereitgestellt haben.

Verwendung von insertMany() Methode

Um Szenarien abzudecken, in denen Sie mehrere Dokumente gleichzeitig einfügen möchten, ist die insertMany() Methode wird jetzt empfohlen. Genauso wie beim Einfügen mehrerer Dokumente mit insert() , insertMany() nimmt ein Array von Dokumenten.

Wir können drei neue Schüler namens Jasmine, Michael und Toni hinzufügen:

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")        ]}
 

Wie bei insertOne() , insertMany() gibt ein Dokument zurück, das den Schreibvorgang bestätigt und ein Array bereitstellt, das die IDs enthält, die den eingefügten Dokumenten zugewiesen wurden.

Abfrage nach vorhandenen Dokumenten

Das Abfragen von Dokumenten ist ein ziemlich umfangreiches Thema, das einen eigenen Artikel verdient. Einzelheiten zum Formulieren von Abfragen zum Abrufen verschiedener Dokumenttypen finden Sie in unserem Leitfaden zum Abfragen von Daten in MongoDB.

Während die Details am besten in dem oben verlinkten Artikel hinterlassen werden, können wir zumindest die Methoden behandeln, die MongoDB zum Abfragen von Dokumenten bereitstellt. Die Hauptmethode zum Abrufen von Dokumenten aus MongoDB ist der Aufruf von find() -Methode für die betreffende Sammlung.

Zum Beispiel, um alle Unterlagen von den students einzusammeln , können Sie find() aufrufen ohne Argumente:

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" }
 

Um die Ausgabe lesbarer zu machen, können Sie pretty() auch verketten Methode nach 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"}
 

Sie können das an einer _id sehen Feld wurde jedem der Dokumente hinzugefügt. MongoDB erfordert eine eindeutige _id für jedes Dokument in einer Sammlung. Wenn Sie bei der Objekterstellung keine angeben, wird eine für Sie hinzugefügt. Sie können diese ID verwenden, um ein einzelnes Objekt zuverlässig abzurufen:

db.students.find(    {        _id : ObjectId("60e8792d4655cbf49ff7cb89")    })
 

{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler" }
 

Mehr über verschiedene Möglichkeiten der Datenabfrage erfahren Sie im oben verlinkten Artikel.

Vorhandene Dokumente aktualisieren

Viele oder die meisten Anwendungsfälle für Datenbanken erfordern, dass Sie vorhandene Daten innerhalb der Datenbank ändern können. Möglicherweise muss ein Feld aktualisiert werden, um einen neuen Wert widerzuspiegeln, oder Sie müssen möglicherweise zusätzliche Informationen an ein vorhandenes Dokument anhängen, sobald diese verfügbar sind.

MongoDB verwendet einige verwandte Methoden, um vorhandene Dokumente zu aktualisieren:

• updateOne() :Aktualisiert ein einzelnes Dokument innerhalb einer Sammlung basierend auf dem bereitgestellten Filter.
• updateMany() :Aktualisiert mehrere Dokumente in einer Sammlung, die dem bereitgestellten Filter entsprechen.
• replaceOne() :Ersetzt ein ganzes Dokument in einer Sammlung basierend auf dem bereitgestellten Filter.

Wir werden behandeln, wie Sie jede dieser Varianten verwenden, um verschiedene Arten von Aktualisierungen durchzuführen.

Operatoren aktualisieren

Bevor wir uns die einzelnen Methoden zum Aktualisieren von Dokumenten ansehen, sollten wir einige der verfügbaren Aktualisierungsoperatoren durchgehen.

• $currentDate :Legt den Wert eines Felds auf das aktuelle Datum fest, entweder als Datums- oder als Zeitstempeltyp.
  • Syntax:{ $currentDate: { <field>: <type>, ... } }
• $inc :Erhöht den Wert eines Felds um einen festgelegten Betrag.
  • Syntax:{ $inc: { <field>: <amount>, ... } }
• $min :Aktualisiert den Wert eines Felds, wenn der angegebene Wert kleiner als der aktuelle Wert ist.
  • Syntax:{ $min: { <field>: <value>, ... } }
• $max :Aktualisiert den Wert eines Felds, wenn der angegebene Wert größer als der aktuelle Wert ist.
  • Syntax:{ $max: { <field>: <value>, ... } }
• $mul :Aktualisiert den Wert eines Feldes durch Multiplikation mit der angegebenen Zahl.
  • Syntax:{ $mul: { <field>: <value>, ... } }
• $rename :Benennt einen Feldnamen in einen neuen Bezeichner um.
  • Syntax:{ $rename: { <field>: <new_name>, ... } }
• $set :Ersetzt den Wert eines Feldes durch den angegebenen Wert.
  • Syntax:{ $set: { <field>: value, ... } }
• $setOnInsert :Legt während Upsert-Operationen den Wert eines Felds fest, wenn ein neues Dokument erstellt wird, und tut ansonsten nichts.
  • Syntax:{ $setOnInsert: { <field>: <value>, ... } }
• $unset :Entfernt ein Feld aus dem Dokument.
  • Syntax:{ $unset: { <field>: "", ... } }
• $ :Ein Platzhalter für das erste Array-Element, das die Abfrage erfüllt.
  • Syntax:{ <update_operator>: {<array>.$: <value> } }
• $[] :Ein Platzhalter für alle Array-Elemente, die die Abfrage erfüllen.
  • Syntax:{ <update_operator>: { <array>.$[]: <value> } }
• $addToSet :Fügt dem Array Werte hinzu, sofern sie nicht bereits vorhanden sind.
  • Syntax:{ $addToSet: { <field>: <value>, ... } }
• $pop :Entfernt das erste oder letzte Element eines Arrays.
  • Syntax:{ $pop: { <field>: (-1 or 1), ... } }
• $pull :Entfernt alle Elemente eines Arrays, die einer Bedingung entsprechen.
  • Syntax:{ $pull: { <field>: <condition>, ... } }
• $push :Hängt einen Wert an ein Array an.
  • Syntax:{ $push: { <field>: <value>, ... } }
• $pullAll :Entfernt alle angegebenen Elemente aus einem Array.
  • Syntax:{ $pullAll: { <field>: [ <value>, ... ], ...} }
• $each :Ändert $addToSet und $push Operatoren, sodass sie jedes Element eines Arrays anstelle eines Arrays als einzelnes Element hinzufügen.
  • Syntax:{ <update_operator>: { <field>: { $each: [ <value>, ... ] }, ... } }
• $position :Wird mit $each verwendet und gibt die Position des $push an Operator sollte at.
  einfügen
  • Syntax:{ $push: { <field>: { $each: [ <value>, ... ], $position: <num> } } }
• $slice :Wird mit $each verwendet und $push um die Anzahl der Gesamtelemente im Array zu begrenzen.
  • Syntax:{ $push: { <field>: { $each: [ <value>, ... ], $slice: <num> } } }
• $sort :Wird mit $each verwendet und $push um Array-Elemente zu sortieren.
  • Syntax:{ $push: { <field>: { $each: [ <value>, ... ], $sort: <sort_order> } } }

Diese verschiedenen Aktualisierungsoperatoren ermöglichen es Ihnen, verschiedene Felder Ihrer Dokumente auf unterschiedliche Weise zu aktualisieren.

Aktualisierung eines einzelnen Dokuments in einer Sammlung

updateOne() von MongoDB -Methode wird verwendet, um ein einzelnes Dokument innerhalb einer Sammlung zu aktualisieren. Die Methode benötigt zwei erforderliche Argumente sowie ein Dokument, das optionale Argumente angibt.

Das erste Argument ist ein Dokument, das die Filterbedingungen angibt, die zum Auswählen von Dokumenten verwendet werden. Seit dem updateOne() -Methode höchstens ein Dokument in einer Sammlung ändert, wird das erste Dokument verwendet, das die Filterbedingungen erfüllt.

Das zweite Argument gibt die Aktualisierungsoperation an, die ausgeführt werden soll. Die oben angegebenen Aktualisierungsoperationen können hier angegeben werden, um den Inhalt des abgeglichenen Dokuments zu ändern.

Das dritte Argument ist ein Dokument mit verschiedenen Optionen, um das Verhalten der Methode zu ändern. Die wichtigsten möglichen Werte sind:

• upsert :Wandelt die Operation in eine Upsert-Prozedur um, indem ein neues Dokument eingefügt wird, wenn der Filter mit keinem vorhandenen Dokument übereinstimmt.
• collation :Ein Dokument, das sprachspezifische Regeln definiert, die für die Operation gelten sollen.

Als Beispiel können wir einen einzelnen Schülerdatensatz aktualisieren, den wir nach _id filtern Feld, um sicherzustellen, dass wir auf das richtige Dokument abzielen. Wir können den grade_level festlegen auf einen neuen Wert:

db.students.updateOne(    { _id: ObjectId("60e8792d4655cbf49ff7cb89") },    { $set: { grade_level: 3 } })
 

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
 

Aktualisieren mehrerer Dokumente in einer Sammlung

updateMany() von MongoDB Methode funktioniert ähnlich wie updateOne() -Methode, sondern aktualisiert stattdessen jedes Dokument, das mit dem angegebenen Filter übereinstimmt, anstatt nach der ersten Übereinstimmung aufzuhören.

Das updateMany() Syntax folgt genau dem updateOne() Syntax, sodass der einzige Unterschied der Umfang der Operation ist.

Als Beispiel, wenn wir alle Instanzen von „composition“ in „writing“ in den subjects ändern wollen -Array in unseren teachers Sammlungsdokumente, könnten wir so etwas verwenden:

db.teachers.updateMany(    { subject: "composition" },    { $set: { "subjects.$": "writing" } })
 

{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }
 

Wenn Sie die Dokumente überprüfen, sollte jede Instanz von "composition" durch "writing" ersetzt worden sein:

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" ] }
 

Ersetzen eines Dokuments

Das replaceOne() Methode funktioniert ähnlich wie updateOne() -Methode, ersetzt jedoch das gesamte Dokument, anstatt einzelne Felder zu aktualisieren. Die Syntax ist dieselbe wie bei den beiden vorherigen Befehlen.

Wenn beispielsweise Nancy Smith Ihre Schule verlässt und Sie sie durch eine Lehrerin namens Clara Newman ersetzen, die Literatur unterrichtet, könnten Sie Folgendes eingeben:

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

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
 

Sie können sehen, dass das übereinstimmende Dokument entfernt und durch das angegebene Dokument ersetzt wurde:

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" ] }
 

So löschen Sie Dokumente

Das Entfernen von Dokumenten aus Sammlungen ist ebenfalls Teil des Dokumentenlebenszyklus. Um ein Dokument zu entfernen, können Sie deleteOne() verwenden oder deleteMany() Methoden. Sie haben die gleiche Syntax und unterscheiden sich nur darin, wie viele Dokumente sie bearbeiten.

Zum größten Teil müssen Sie zum Löschen von Dokumenten mit einer dieser Methoden lediglich ein Filterdokument bereitstellen, das angibt, wie Sie das zu löschende Dokument auswählen möchten. Das deleteOne() -Methode löscht höchstens ein Dokument (unabhängig davon, wie viele Übereinstimmungen der Filter erzeugt), während die deleteMany() Methode löscht jedes Dokument, das den Filterbedingungen entspricht.

Um beispielsweise einen einzelnen Schüler zu löschen, können Sie eine _id angeben um sie explizit abzugleichen:

db.students.deleteOne({    _id: ObjectId("60e8792d4655cbf49ff7cb87")})
 

{ "acknowledged" : true, "deletedCount" : 1 }
 

Wenn wir einen Schüler löschen möchten, dem keine Klassenstufe zugewiesen ist, können wir deleteMany() verwenden Methode stattdessen:

db.students.deleteMany({    grade_level: { $eq: null }})
 

{ "acknowledged" : true, "deletedCount" : 2 }
 

Wenn wir das überprüfen, sollten wir sehen, dass allen verbleibenden Schülern eine Klassenstufe zugewiesen wurde:

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 }
 

Fazit

Wenn Sie lernen, wie Sie Dokumente erstellen, abfragen, aktualisieren und entfernen, erhalten Sie die Fähigkeiten, die Sie benötigen, um Dokumente täglich in MongoDB effektiv zu verwalten. Wenn Sie sich mit den verschiedenen Dokument- und Erfassungsmethoden und den Operatoren vertraut machen, die es Ihnen ermöglichen, Informationen abzugleichen und zu ändern, können Sie komplexe Gedanken ausdrücken, die das Datenbanksystem verstehen kann.