MongoDB CRUD-Operationen

Inhaltsverzeichnis

• Grundlegende Definition der CRUD-Operation
• Beispiele für grundlegende Operationen
• Was ist CRUD in MongoDB?
• Ausführuen von CRUD-Operationen
• CRUD-Leistung in relationalen vs. nicht relationalen Datenbanken
• Fazit
• Häufig gestellte Fragen

Grundlegende Definition der CRUD-Operation

Die meisten transaktionalen Interaktionen, die ein Benutzer mit einer digitalen Plattform wie einer Website oder einer Webanwendung hat, beinhalten Anfragen für vier grundlegende Operationen:

• Etwas Neues erstellen (z. B. ein Kundenprofil).
• Datensatz lesen (z. B. Abruf von Bestelldaten für einen Benutzer).
• Informationen aktualisieren (z. B. Handynummer oder E-Mail-Adresse eines Nutzers).
• Datensatz löschen (beispielsweise einer geschäftlichen Telefonnummer).

CRUD ist datenorientiert und nach HTTP-Aktionsverben standardisiert. Das Frontend einer Anwendung erfasst die Informationen und sendet sie als HTTP-Anfrage an die Middleware, die die entsprechenden Datenbankfunktionen aufruft, um die Aufgabe abzuschließen. Diese vier grundlegenden Funktionen werden zusammen als CRUD bezeichnet, das Akronym für create, read, update und delete.

Beispiele für grundlegende Operationen

CRUD-Methoden sind die primären Möglichkeiten zur Verwaltung der Daten in Ihren Datenbanken. CRUD-Operationen sind für jede Anwendung unverzichtbar, ganz gleich, ob es sich um eine Massenoperation oder eine einzelne handelt.

Einige Beispiele für eine Create-Operation sind das Anlegen eines neuen Benutzerprofils in der Datenbank, das Anlegen eines Warenkorbs für den Benutzer und das Anlegen eines neuen Buchkatalogs (Masseneinfügung).

Einige Beispiele für Read-Operationen sind das Abrufen von Produktdetails für bestimmte Suchkriterien durch den Benutzer, etwa wenn ein Benutzer nach einem Mobiltelefon der Marke „Apple“ sucht; das Anzeigen aller iPhone-Modelle; das Anzeigen der Warenkorbinformationen eines Benutzers und das Anzeigen von Mitarbeiterdetails auf dem Portal.

Beispiele für Update-Operationen sind die Aktualisierung der persönlichen Daten eines Benutzers, des Warenkorbs, der Rechnungsadresse, des Zeitstempels oder der Seriennummer einer bestimmten Produktreihe (Massenaktualisierung).

Einige Beispiele für Delete-Operationen sind das Löschen von Produkten aus dem Warenkorb eines Benutzers, das Löschen eines Buches aus den Favoriten und das Löschen aller Datensätze, die älter als ein bestimmter Zeitraum sind (Massenlöschung).

Lassen Sie uns die Definition von CRUD genauer untersuchen und prüfen, wie CRUD-Operationen in MongoDB mit der MongoDB Query Language (MQL) ausgeführt werden.

Was ist CRUD in MongoDB?

CRUD-Operationen beschreiben die Konventionen einer Benutzeroberfläche, die es Benutzern ermöglichen, Teile der Datenbank anzuzeigen, zu durchsuchen und zu ändern. MongoDB bietet über seine Treiber eine elegante Möglichkeit, CRUD-Operationen mit der Programmiersprache Ihrer Wahl durchzuführen.

MongoDB-Dokumente werden geändert, indem eine Verbindung zu einem Server hergestellt, die entsprechenden Dokumente abgefragt und dann die Einstellungseigenschaften geändert werden, bevor die Daten zur Aktualisierung an die Datenbank zurückgesendet werden.

Einzelne CRUD-Operationen:

• Die Operation create wird verwendet, um neue Dokumente in die MongoDB-Datenbank einzufügen.
• Die Operation read wird verwendet, um ein Dokument in der Datenbank abzufragen.
• Die Operation update wird verwendet, um vorhandene Dokumente in der Datenbank zu ändern.
• Die Operation delete wird verwendet, um Dokumente aus der Datenbank zu entfernen.

So führen Sie CRUD-Operationen durch

Nachdem wir nun die MongoDB-CRUD-Operationen definiert haben, können wir uns ansehen, wie die einzelnen Operationen ausgeführt und Dokumente in einer MongoDB-Datenbank bearbeitet werden. Gehen wir nun auf die Vorgänge des Erstellens, Lesens, Aktualisierens und Löschens von Dokumenten ein, wobei wir die einzelnen Operationen nacheinander betrachten.

Operation „Create“

Für MongoDB CRUD: Wenn die angegebene Sammlung nicht existiert, wird mit der Operation create die Sammlung erstellt, wenn sie ausgeführt wird. Create-Operationen in MongoDB zielen auf eine einzelne Sammlung ab, nicht auf mehrere Sammlungen. Einfügevorgänge in MongoDB sind atomar auf einem einzelnen Dokument Level.

MongoDB bietet zwei verschiedene Create-Operationen, mit denen Sie Dokumente in eine Sammlung einfügen können:

• db.collection.insertOne()
• db.collection.insertMany()

insertOne()

Wie der Name schon sagt, können Sie mit insertOne() ein Dokument in die Sammlung einfügen. In diesem Beispiel werden wir mit einer Sammlung namens RecordsDB arbeiten. Wir können einen einzelnen Eintrag in unsere Sammlung einfügen, indem wir die Methode insertOne() in RecordsDB aufrufen. Anschließend geben wir die Informationen, die wir einfügen möchten, in Form von Schlüssel-Wert-Paaren ein und erstellen so das Schema.

db.RecordsDB.insertOne({
    name: "Marsh",
    age: "6 years",
    species: "Dog",
    ownerAddress: "380 W. Fir Ave",
    chipped: true
})

Wenn die Create-Operation erfolgreich ist, wird ein neues Dokument erstellt. Die Funktion gibt ein Objekt zurück, bei dem „acknowledged“ „true“ und „insertID“ die neu erstellte „ObjectId“ ist.

> db. RecordsDB.insertOne({
... name: "Marsh",
... age: "6 years",
... species: "Dog",
... ownerAddress: "380 W. Fir Ave",
... chipped: true
... })
{
        "acknowledged" : true,
        "insertedId" : ObjectId("5fd989674e6b9ceb8665c57d")
}

insertMany()

Es ist möglich, mehrere Elemente gleichzeitig einzufügen, indem Sie die Methode insertMany() für die gewünschte Sammlung aufrufen. In diesem Fall übergeben wir mehrere Elemente an unsere ausgewählte Sammlung (RecordsDB) und trennen sie durch Kommas. Innerhalb der Klammern verwenden wir Klammern, um anzuzeigen, dass wir eine Liste mit mehreren Einträgen übergeben. Dies wird allgemein als verschachtelte Methode bezeichnet.

 db.RecordsDB.insertMany([{
    name: "Marsh",
    age: "6 years",
    species: "Dog",
    ownerAddress: "380 W. Fir Ave",
    chipped: true},
      {name: "Kitana", 
      age: "4 years", 
      species: "Cat", 
      ownerAddress: "521 E. Cortland", 
      chipped: true}])

 db.RecordsDB.insertMany([{ name: "Marsh", age: "6 years", species: "Dog", 
ownerAddress: "380 W. Fir Ave", chipped: true}, {name: "Kitana", age: "4 years", 
species: "Cat", ownerAddress: "521 E. Cortland", chipped: true}])
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("5fd98ea9ce6e8850d88270b4"),
                ObjectId("5fd98ea9ce6e8850d88270b5")
        ]
}

Read-Operationen

Mithilfe von Operationen Read können Sie spezielle Abfragefilter und Kriterien angeben, mit denen Sie die gewünschten Dokumente spezifizieren können. Die MongoDB-Dokumentation enthält weitere Informationen zu den verfügbaren Abfragefiltern. Abfragemodifikatoren können auch verwendet werden, um die Anzahl der zurückgegebenen Ergebnisse zu ändern.

MongoDB bietet zwei Methoden zum Lesen von Dokumenten aus einer Sammlung:

• db.collection.find()
• db.collection.findOne()

find()

Um alle Dokumente aus einer Sammlung zu erhalten, können wir einfach die Methode find() auf unsere ausgewählte Sammlung anwenden. Wenn Sie nur die Methode find() ohne Argumente ausführen, werden alle Datensätze zurückgegeben, die sich aktuell in der Sammlung befinden.

 db.RecordsDB.find()

{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "4 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }
{ "_id" : ObjectId("5fd993a2ce6e8850d88270b7"), "name" : "Marsh", "age" : "6 years", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }
{ "_id" : ObjectId("5fd993f3ce6e8850d88270b8"), "name" : "Loo", "age" : "3 years", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }
{ "_id" : ObjectId("5fd994efce6e8850d88270ba"), "name" : "Kevin", "age" : "8 years", "species" : "Dog", "ownerAddress" : "900 W. Wood Way", "chipped" : true }

Im Ergebnis sehen wir alle in der Sammlung vorhandenen Datensätze. Beachten Sie, dass jedem Datensatz eine „ID“ zugewiesen ist, die dem Schlüssel „_id“ zugeordnet ist.

Wenn Sie mit einer Read-Operation spezifischer vorgehen und einen gewünschten Teilbereich der Datensätze finden möchten, können Sie die zuvor erwähnten Filterkriterien verwenden, um auszuwählen, welche Ergebnisse zurückgegeben werden sollen. Eine der gängigsten Methoden zum Filtern der Ergebnisse ist die Suche nach Wert.

db.RecordsDB.find({"species":"Cat"})

{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "4 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }

findOne ()

Um ein Dokument zu erhalten, das die Suchkriterien erfüllt, können wir einfach die findOne()-Methode für unsere gewählte Sammlung verwenden. Wenn mehrere Dokumente die Abfrage erfüllen, gibt diese Methode das erste Dokument gemäß der natürlichen Reihenfolge zurück, die die Reihenfolge der Dokumente auf der Festplatte widerspiegelt. Wenn keine Dokumente die Suchkriterien erfüllen, gibt die Funktion null zurück. Die Funktion hat die folgende Syntax-Form.

 db.{collection}.findOne({query}, {projection})

Nehmen wir als Beispiel die folgende Sammlung, RecordsDB.

{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "8 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }
{ "_id" : ObjectId("5fd993a2ce6e8850d88270b7"), "name" : "Marsh", "age" : "6 years", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }
{ "_id" : ObjectId("5fd993f3ce6e8850d88270b8"), "name" : "Loo", "age" : "3 years", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }
{ "_id" : ObjectId("5fd994efce6e8850d88270ba"), "name" : "Kevin", "age" : "8 years", "species" : "Dog", "ownerAddress" : "900 W. Wood Way", "chipped" : true }

Und wir führen die folgende Codezeile aus:

db. RecordsDB.find({"age":"8 years"})

Wir würden folgendes Ergebnis erhalten:

{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "8 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }

Beachten Sie, dass, obwohl zwei Dokumente die Suchkriterien erfüllen, nur das erste Dokument zurückgegeben wird, das der Suchbedingung entspricht.

Update-Operationen

Wie Create-Operationen werden die Operationen Update mit einer einzigen Sammlung ausgeführt und sind auf einer einzelnen Dokumentebene atomar. Bei einer Update-Operation werden Filter und Kriterien verwendet, um die Dokumente auszuwählen, die Sie aktualisieren möchten.

Sie sollten vorsichtig sein, wenn Sie Dokumente aktualisieren, da Aktualisierungen permanent sind und nicht rückgängig gemacht werden können. Dies gilt auch für Delete-Operationen.

Für MongoDB CRUD gibt es drei verschiedene Methoden zum Aktualisieren von Dokumenten:

• db.collection.updateOne()
• db.collection.updateMany()
• db.Collection.ReplaceOne()

updateOne()

Wir können einen aktuell vorhandenen Datensatz aktualisieren und ein einzelnes Dokument mit einer Update-Operation ändern. Dazu verwenden wir die Methode updateOne() für eine ausgewählte Sammlung, die hier „RecordsDB“ ist. Um ein Dokument zu aktualisieren, stellen wir der Methode zwei Argumente zur Verfügung: einen Update-Filter und eine Update-Aktion.

Der Update-Filter definiert, welche Elemente aktualisiert werden sollen, und die Filter-Aktion definiert, wie diese Elemente aktualisiert werden. Wir übergeben zuerst den Update-Filter. Dann verwenden wir den Schlüssel „$set“ und geben die Felder, die wir aktualisieren möchten, als Wert an. Diese Methode aktualisiert den ersten Datensatz, der dem angegebenen Filter entspricht.

 db.RecordsDB.updateOne({name: "Marsh"}, {$set:{ownerAddress: "451 W. Coffee St. A204"}})

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

{ "_id" : ObjectId("5fd993a2ce6e8850d88270b7"), "name" : "Marsh", "age" : "6 years", "species" : "Dog", "ownerAddress" : "451 W. Coffee St. A204", "chipped" : true }

updateMany()

updateMany() ermöglicht es uns, mehrere Elemente zu aktualisieren, indem wir eine Liste von Elementen übergeben, genau wie beim Einfügen mehrerer Elemente. Diese Update-Operation verwendet dieselbe Syntax für die Aktualisierung eines einzelnen Dokuments.

 db.RecordsDB.updateMany({species:"Dog"}, {$set: {age: "5"}})

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

 > db.RecordsDB.find()
{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "4 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }
{ "_id" : ObjectId("5fd993a2ce6e8850d88270b7"), "name" : "Marsh", "age" : "5", "species" : "Dog", "ownerAddress" : "451 W. Coffee St. A204", "chipped" : true }
{ "_id" : ObjectId("5fd993f3ce6e8850d88270b8"), "name" : "Loo", "age" : "5", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }
{ "_id" : ObjectId("5fd994efce6e8850d88270ba"), "name" : "Kevin", "age" : "5", "species" : "Dog", "ownerAddress" : "900 W. Wood Way", "chipped" : true }

replaceOne()

Die Methode replaceOne() ersetzt ein einzelnes Dokument in der angegebenen Sammlung. replaceOne() ersetzt das gesamte Dokument, was bedeutet, dass Felder im alten Dokument, die nicht im neuen enthalten sind, verloren gehen.

 db.RecordsDB.replaceOne({name: "Kevin"}, {name: "Maki"})

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

 > db.RecordsDB.find()
{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "4 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }
{ "_id" : ObjectId("5fd993a2ce6e8850d88270b7"), "name" : "Marsh", "age" : "5", "species" : "Dog", "ownerAddress" : "451 W. Coffee St. A204", "chipped" : true }
{ "_id" : ObjectId("5fd993f3ce6e8850d88270b8"), "name" : "Loo", "age" : "5", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }
{ "_id" : ObjectId("5fd994efce6e8850d88270ba"), "name" : "Maki" }

Delete-Operationen

Operationen Delete operieren auf einer einzigen Sammlung, wie Update- und Create-Operationen. Delete-Operationen sind ebenfalls atomar für ein einzelnes Dokument. Sie können Delete-Operationen mit Filtern und Kriterien versehen, um anzugeben, welche Dokumente Sie aus einer Sammlung löschen möchten. Die Filteroptionen basieren auf der gleichen Syntax wie bei Read-Operationen.

MongoDB verfügt über zwei verschiedene Methoden zum Löschen von Datensätzen aus einer Sammlung:

• db.collection.deleteOne()
• db.collection.deleteMany()

deleteOne()

deleteOne() entfernt ein Dokument aus einer angegebenen Sammlung auf dem MongoDB-Server. Ein Filterkriterium wird verwendet, um das zu löschende Element anzugeben. Es löscht den ersten Datensatz, der dem angegebenen Filter entspricht.

 db.RecordsDB.deleteOne({name:"Maki"})

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

 > db.RecordsDB.find()
{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "4 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }
{ "_id" : ObjectId("5fd993a2ce6e8850d88270b7"), "name" : "Marsh", "age" : "5", "species" : "Dog", "ownerAddress" : "451 W. Coffee St. A204", "chipped" : true }
{ "_id" : ObjectId("5fd993f3ce6e8850d88270b8"), "name" : "Loo", "age" : "5", "species" : "Dog", "ownerAddress" : "380 W. Fir Ave", "chipped" : true }

deleteMany()

deleteMany() ist eine Methode, die verwendet wird, um mehrere Dokumente aus einer gewünschten Sammlung mit einer einzigen Delete-Operation zu löschen. Es wird eine Liste an die Methode übergeben und die einzelnen Elemente werden mit Filterkriterien wie in deleteOne() definiert.

 db.RecordsDB.deleteMany({species:"Dog"})

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

 > db.RecordsDB.find()
{ "_id" : ObjectId("5fd98ea9ce6e8850d88270b5"), "name" : "Kitana", "age" : "4 years", "species" : "Cat", "ownerAddress" : "521 E. Cortland", "chipped" : true }

CRUD-Leistung in relationalen vs. nicht-relationalen Datenbanken

NoSQL-Datenbanken sind besser für Create- und Read-Operationen optimiert und bieten mehr Skalierbarkeit. Sie eignen sich daher gut für höhere Lasten (können mehr CRUD-Operationen bewältigen). Sie sind auch flexibel in Bezug auf die Speicherung von Informationen.

In einem detaillierten Experiment, das von ResearchGate an CRUD-Operationen durchgeführt wurde, die mit verschiedenen Arten von NoSQL- und SQL-Datenbanken durchgeführt wurden, kam man zu dem Schluss, dass NoSQL-Datenbanken bei allen CRUD-Operationen deutlich besser abschnitten als SQL-Datenbanken, insbesondere wenn die Anzahl der Operationen hoch war. MongoDB beispielsweise schnitt beim Abrufen von Daten (Read-Operationen) hervorragend ab, mit einer durchschnittlichen Leistungszeit von 43,5 ms für 100.000 Read-Operationen (Suchen/Auswählen). MongoDB bietet außerdem den Vorteil, dass es atomare Updates (Updates auf Feldebene) bereitstellt, was bei jeder anderen dokumentenorientierten Datenbank zeitaufwändiger ist.

Fazit

Dieser Artikel enthält grundlegende Informationen zu CRUD sowie einige Beispiele zur Durchführung von CRUD-Operationen in MongoDB. MongoDB Atlas bietet eine einfache Möglichkeit, CRUD-Operationen mithilfe der Benutzeroberfläche durchzuführen. Mehr grundlegende MongoDB-CRUD-Konzepte zur Entwicklung hochperformanter, skalierbarer Anwendungen finden Sie im MongoDB-Handbuch.

Verwandter Inhalt:

• Kurs der MongoDB University - M201: MongoDB-Leistung
• Was ist Replikation in MongoDB?
• Anleitung für Anfänger: MongoDB-Grundlagen
• ACID-Transaktionen in MongoDB verwenden
• Einbetten von Dokumenten in MongoDB
• MongoDB-Beispiele
• Top 5 der Best Practices für MongoDB-Sicherheit