MongoDB CRUD-Operationen meistern: Ein praktischer Befehlsleitfaden

MongoDB, eine beliebte NoSQL-Dokumentendatenbank, bildet aufgrund seiner Flexibilität, Skalierbarkeit und Leistungsfähigkeit das Rückgrat unzähliger moderner Anwendungen. Im Zentrum der Interaktion mit jeder Datenbank stehen die grundlegenden Create-, Read-, Update- und Delete-Operationen (CRUD). Die Beherrschung dieser Befehle ist für jeden, der mit MongoDB arbeitet, unerlässlich – von Entwicklern, die neue Funktionen erstellen, bis zu Administratoren, die Daten verwalten.

Dieser Leitfaden verwendet eine kleine users-Sammlung und zeigt die MongoDB-CRUD-Befehle, die Sie bei der täglichen Arbeit benötigen: Hinzufügen eines Datensatzes aus einem Anmeldeformular, Finden des Dokuments hinter einem Support-Ticket, Ändern eines Feldes, ohne den Rest des Dokuments zu überschreiben, und Löschen von Daten, ohne versehentlich die gesamte Sammlung zu leeren. Die Beispiele verwenden mongosh, aber die gleichen Filter und Update-Operatoren lassen sich auf Anwendungstreiber übertragen.

Voraussetzungen

Bevor Sie mit den Befehlen beginnen, stellen Sie sicher, dass Folgendes vorhanden ist:

• MongoDB installiert und ausgeführt: Sie können es von der offiziellen MongoDB-Website herunterladen oder einen Cloud-Dienst wie MongoDB Atlas nutzen.
• mongosh (MongoDB Shell) installiert: Dies ist die interaktive JavaScript-Schnittstelle für MongoDB.

Verbindung zu MongoDB herstellen und eine Datenbank auswählen

Öffnen Sie Ihr Terminal oder Ihre Eingabeaufforderung und verbinden Sie sich mit mongosh mit Ihrer MongoDB-Instanz:

mongosh

Nach der Verbindung befinden Sie sich in der Standarddatenbank test. Um zu einer neuen Datenbank zu wechseln oder eine zu erstellen, verwenden Sie den Befehl use:

use myDatabase;

Falls myDatabase nicht existiert, erstellt MongoDB sie implizit, sobald Sie Ihr erstes Dokument in eine Sammlung innerhalb dieser Datenbank einfügen.

Create-Operationen (Einfügen)

Create-Operationen fügen einer Sammlung neue Dokumente hinzu. MongoDB bietet Methoden zum Einfügen einzelner oder mehrerer Dokumente.

1. db.collection.insertOne()

Diese Methode fügt ein einzelnes Dokument in eine Sammlung ein. Wenn die Sammlung nicht existiert, erstellt MongoDB sie.

// Eine Sammlung namens 'users' auswählen
db.users.insertOne({
  name: "Alice Smith",
  age: 30,
  city: "New York",
  email: "[email protected]",
  interests: ["reading", "hiking"]
});

Die Ausgabe zeigt den acknowledged-Status und die insertedId des neuen Dokuments.

2. db.collection.insertMany()

Verwenden Sie diese Methode, um mehrere Dokumente in einem einzigen Vorgang in eine Sammlung einzufügen. Sie nimmt ein Array von Dokumenten entgegen.

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

Dies gibt ein Array von insertedIds für alle hinzugefügten Dokumente zurück.

Tipp: MongoDB fügt jedem Dokument automatisch ein _id-Feld (eine eindeutige ObjectId) hinzu, wenn Sie keines angeben.

Read-Operationen (Finden)

Read-Operationen fragen Dokumente aus einer Sammlung ab. Die Methode find() ist Ihr primäres Werkzeug dafür.

1. db.collection.find()

a. Alle Dokumente finden

Um alle Dokumente in einer Sammlung abzurufen, rufen Sie find() ohne Argumente auf:

db.users.find();

b. Dokumente mit einem Query-Filter finden

Übergeben Sie ein Query-Dokument an find(), um Kriterien für die Auswahl von Dokumenten anzugeben. Dies fungiert als WHERE-Klausel in SQL.

// Benutzer aus New York finden
db.users.find({ city: "New York" });

// Benutzer älter als 25 finden
db.users.find({ age: { $gt: 25 } });

// Benutzer mit Alter zwischen 25 und 35 (exklusive 35) finden
db.users.find({ age: { $gt: 25, $lt: 35 } });

// Benutzer finden, deren Interessen 'coding' beinhalten
db.users.find({ interests: "coding" });

// Benutzer finden, deren Interessen SOWOHL 'reading' als auch 'hiking' beinhalten
db.users.find({ interests: { $all: ["reading", "hiking"] } });

// Benutzer namens Alice Smith ODER aus London finden
db.users.find({
  $or: [
    { name: "Alice Smith" },
    { city: "London" }
  ]
});

Häufige Query-Operatoren:

• $eq: Gleich (Standard, wenn kein Operator angegeben ist)
• $ne: Ungleich
• $gt: Größer als
• $gte: Größer oder gleich
• $lt: Kleiner als
• $lte: Kleiner oder gleich
• $in: Entspricht einem der in einem Array angegebenen Werte
• $nin: Entspricht keinem der in einem Array angegebenen Werte
• $and, $or, $not, $nor: Logische Operatoren

c. Projektion: Bestimmte Felder auswählen

Um nur eine Teilmenge von Feldern zurückzugeben, übergeben Sie ein Projektionsdokument als zweites Argument an find(). Ein Wert von 1 schließt das Feld ein, 0 schließt es aus. Das _id-Feld ist standardmäßig enthalten, sofern es nicht explizit ausgeschlossen wird.

// Nur Name und E-Mail zurückgeben, _id ausschließen
db.users.find({ city: "New York" }, { name: 1, email: 1, _id: 0 });

d. Sortieren, Begrenzen und Überspringen

Durch Verkettung von Methoden sind komplexere Abfragen möglich:

// Absteigend nach Alter sortieren (1 für aufsteigend, -1 für absteigend)
db.users.find().sort({ age: -1 });

// Ergebnisse auf 2 Dokumente begrenzen
db.users.find().limit(2);

// Die ersten 2 Dokumente überspringen und den Rest zurückgeben
db.users.find().skip(2);

// Operationen kombinieren: Benutzer aus New York finden, nach Alter sortieren, 1 überspringen, 1 begrenzen
db.users.find({ city: "New York" }).sort({ age: 1 }).skip(1).limit(1);

2. db.collection.findOne()

Diese Methode gibt ein einzelnes Dokument zurück, das den Abfragekriterien entspricht. Wenn mehrere Dokumente übereinstimmen, wird das zuerst gefundene zurückgegeben.

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

Update-Operationen

Update-Operationen ändern vorhandene Dokumente in einer Sammlung. Sie können ein einzelnes Dokument, mehrere Dokumente oder sogar ein gesamtes Dokument ersetzen.

1. db.collection.updateOne()

Aktualisiert ein einzelnes Dokument, das den Filterkriterien entspricht.

// Alices Stadt auf 'San Francisco' aktualisieren
db.users.updateOne(
  { name: "Alice Smith" },
  { $set: { city: "San Francisco", lastUpdated: new Date() } }
);

2. db.collection.updateMany()

Aktualisiert alle Dokumente, die den Filterkriterien entsprechen.

// Das Alter aller Benutzer in New York um 1 erhöhen
db.users.updateMany(
  { city: "New York" },
  { $inc: { age: 1 } }
);

// Ein neues Interesse 'reading' zu Benutzern hinzufügen, die es noch nicht haben
db.users.updateMany(
  {}, // Auf alle Dokumente anwenden
  { $addToSet: { interests: "reading" } }
);

// 'gaming' aus den Interessen von Bob Johnson entfernen
db.users.updateOne(
  { name: "Bob Johnson" },
  { $pull: { interests: "gaming" } }
);

Häufige Update-Operatoren:

• $set: Setzt den Wert eines Feldes in einem Dokument. Erstellt das Feld, falls es nicht existiert.
• $inc: Erhöht den Wert eines Feldes um einen bestimmten Betrag.
• $unset: Entfernt ein Feld aus einem Dokument.
• $push: Fügt einem Array-Feld einen Wert hinzu.
• $pull: Entfernt alle Instanzen eines Werts oder von Werten, die einer bestimmten Abfrage aus einem Array entsprechen.
• $addToSet: Fügt einem Array einen Wert hinzu, nur wenn der Wert nicht bereits vorhanden ist.

3. db.collection.replaceOne()

Ersetzt ein einzelnes Dokument, das den Filterkriterien entspricht, durch ein neues Dokument. Das _id-Feld des ersetzten Dokuments kann nicht geändert werden.

// Bob Johnsons Dokument vollständig ersetzen
db.users.replaceOne(
  { name: "Bob Johnson" },
  {
    name: "Robert Johnson",
    occupation: "Software Engineer",
    status: "active",
    email: "[email protected]"
  }
);

Upsert-Option

Sowohl updateOne() als auch updateMany() unterstützen eine upsert-Option. Wenn diese auf true gesetzt ist und kein Dokument dem Filter entspricht, fügt MongoDB ein neues Dokument basierend auf der Abfrage und den Update-Operationen ein.

db.users.updateOne(
  { name: "David Lee" },
  { $set: { age: 28, city: "Seattle" } },
  { upsert: true } // Wenn David Lee nicht existiert, wird er erstellt
);

Delete-Operationen

Delete-Operationen entfernen Dokumente aus einer Sammlung. Seien Sie bei Löschvorgängen äußerst vorsichtig, da sie irreversibel sind.

1. db.collection.deleteOne()

Löscht höchstens ein Dokument, das dem angegebenen Filter entspricht.

// Den Benutzer namens 'Robert Johnson' (zuvor 'Bob Johnson') löschen
db.users.deleteOne({ name: "Robert Johnson" });

2. db.collection.deleteMany()

Löscht alle Dokumente, die dem angegebenen Filter entsprechen.

// Alle Benutzer aus London löschen
db.users.deleteMany({ city: "London" });

Warnung: Um alle Dokumente in einer Sammlung zu löschen, verwenden Sie einen leeren Filter {}. Seien Sie äußerst vorsichtig, da dieser Vorgang nicht rückgängig gemacht werden kann:

db.users.deleteMany({}); // Löscht alle Dokumente in der 'users'-Sammlung

3. db.collection.drop()

Diese Methode entfernt dauerhaft eine gesamte Sammlung aus der Datenbank, einschließlich aller ihrer Dokumente und Indizes.

db.users.drop(); // Löscht die gesamte 'users'-Sammlung

Warnung: Das Löschen einer Sammlung ist ein äußerst destruktiver Vorgang. Stellen Sie sicher, dass Sie über geeignete Backups verfügen oder absolut sicher sind, bevor Sie diesen Befehl ausführen.

Best Practices für MongoDB CRUD

• Indizierung: Erstellen Sie für häufig abgefragte Felder Indizes, um Lesevorgänge erheblich zu beschleunigen. db.collection.createIndex({ fieldName: 1 }).
• Projektionen: Rufen Sie nur die Daten ab, die Sie benötigen. Die Verwendung von Projektionen ({ field: 1 }) reduziert Netzwerkbandbreite und Speichernutzung.
• Batch-Operationen: Verwenden Sie beim Einfügen, Aktualisieren oder Löschen vieler Dokumente insertMany(), updateMany() und deleteMany() anstelle einzelner Operationen, um den Overhead zu reduzieren.
• Operatoren verstehen: Machen Sie sich mit der umfangreichen Palette von Abfrage- und Update-Operatoren von MongoDB vertraut. Sie bieten leistungsstarke Möglichkeiten zur Manipulation Ihrer Daten.
• Fehlerbehandlung: Implementieren Sie in einer Produktionsanwendung immer eine robuste Fehlerbehandlung für Ihre Datenbankoperationen.
• Schema-Design: Obwohl MongoDB schema-los ist, ist ein durchdachtes Schema-Design für effiziente Abfragen und Datenkonsistenz entscheidend.

Ein sicherer Weg, CRUD in einer echten Datenbank zu üben

Der gefährliche Teil von MongoDB CRUD ist nicht die Syntax. Es ist die Ausführung eines breiten Filters in der falschen Datenbank, insbesondere mit updateMany() oder deleteMany(). Ich verwende gerne eine Drei-Schritte-Gewohnheit für jeden Schreibvorgang, der vorhandene Daten betrifft.

Führen Sie zuerst den Filter als Lesevorgang aus:

db.users.find(
  { city: "New York", status: "inactive" },
  { name: 1, email: 1, city: 1, status: 1 }
).limit(20);

Wenn die Vorschau Dokumente zurückgibt, die Sie nicht erwartet haben, stoppen Sie hier. Korrigieren Sie den Filter, bevor Sie über das Update nachdenken. Wenn nichts zurückgegeben wird, stellen Sie sicher, dass Sie sich mit db.getName() in der richtigen Datenbank befinden und dass die Feldnamen mit den tatsächlichen Dokumenten übereinstimmen.

Zweitens zählen Sie die übereinstimmenden Dokumente:

db.users.countDocuments({ city: "New York", status: "inactive" });

Dies gibt Ihnen eine grobe Vorstellung vom Umfang. Wenn Sie 12 Benutzer erwartet haben und die Zählung 12.000 ergibt, sagt Ihnen der Befehl, dass etwas nicht stimmt. Eine Zählung ist kein Ersatz für ein Backup, aber sie ist eine kostengünstige Sicherheitsmaßnahme.

Drittens führen Sie den Schreibvorgang mit dem engsten Befehl aus, der für die Aufgabe geeignet ist. Verwenden Sie updateOne(), wenn eine eindeutige E-Mail, Kontonummer oder _id mit einem Dokument übereinstimmen sollte. Verwenden Sie updateMany() nur, wenn die Änderung eines gesamten Segments beabsichtigt ist.

db.users.updateMany(
  { city: "New York", status: "inactive" },
  {
    $set: {
      marketingEmailEnabled: false,
      updatedBy: "ops-maintenance-2025-11-04"
    }
  }
);

Das Hinzufügen eines updatedBy, updatedAt oder eines Wartungshinweises ist von MongoDB nicht erforderlich, hilft aber später, wenn jemand fragt, warum sich ein Feld geändert hat.

Häufige Fehler, die echte Bugs verursachen

Der erste Fehler besteht darin, ein Dokument zu ersetzen, wenn Sie nur ein Feld aktualisieren wollten. Dieser Befehl sieht harmlos aus, ersetzt aber das gesamte übereinstimmende Dokument nur durch die angezeigten Felder:

db.users.updateOne(
  { email: "[email protected]" },
  { city: "Boston" }
);

Modernes MongoDB erwartet Update-Operatoren für Update-Dokumente, es sei denn, Sie verwenden Ersetzungsmethoden. Daher kann dieses Muster je nach Befehl und Version fehlschlagen. Das sicherere mentale Modell ist einfach: Wenn Sie Felder direkt ändern, verwenden Sie $set, $unset, $inc, $push, $pull oder einen anderen Update-Operator.

db.users.updateOne(
  { email: "[email protected]" },
  { $set: { city: "Boston" } }
);

Der zweite Fehler besteht darin, Arrays so abzufragen, als ob die Reihenfolge immer wichtig wäre. { interests: ["reading", "hiking"] } entspricht einem Array exakt. { interests: "reading" } entspricht Dokumenten, in denen das Array diesen Wert enthält. { interests: { $all: ["reading", "hiking"] } } entspricht Arrays, die beide Werte enthalten, unabhängig von der Reihenfolge. Das sind drei verschiedene Fragen.

Der dritte Fehler besteht darin, anzunehmen, dass findOne() „das richtige“ zurückgibt, wenn der Filter nicht eindeutig ist. Wenn Sie ausführen:

db.users.findOne({ city: "New York" });

gibt MongoDB ein übereinstimmendes Dokument zurück, aber ohne eine Sortierung sollten Sie dieses Dokument nicht als das neueste, älteste, wichtigste oder repräsentativste behandeln. Wenn die Reihenfolge wichtig ist, geben Sie dies an:

db.users.find({ city: "New York" }).sort({ createdAt: -1 }).limit(1);

Der vierte Fehler besteht darin, Indizes zu überspringen, bis die Anwendung bereits langsam ist. Eine Sammlung mit einigen tausend Dokumenten kann eine ineffiziente Abfrage verbergen. Dieselbe Abfrage kann schmerzhaft werden, wenn die Sammlung wächst. Wenn die Anwendung häufig Benutzer per email findet, erstellen Sie einen eindeutigen Index, wenn es das Datenmodell zulässt:

db.users.createIndex({ email: 1 }, { unique: true });

Das schützt sowohl die Leistung als auch die Datenqualität. Wenn bereits doppelte E-Mails vorhanden sind, schlägt der Befehl fehl, was genau die Art von Problem ist, das Sie entdecken möchten, bevor Sie sich auf die E-Mail als Identifikator verlassen.

Überprüfen, was ein Schreibvorgang tatsächlich bewirkt hat

Die Ergebnisse von MongoDB-Schreibvorgängen sind es wert, gelesen zu werden. Überprüfen Sie nach einem Update matchedCount und modifiedCount. matchedCount gibt an, wie viele Dokumente dem Filter entsprachen. modifiedCount gibt an, wie viele tatsächlich geändert wurden.

Wenn matchedCount 1 und modifiedCount 0 ist, kann der Befehl dennoch in Ordnung sein. Möglicherweise hatte das Feld bereits den angeforderten Wert. Wenn matchedCount 0 ist, hat Ihr Filter nichts gefunden. Dies ist häufig der Fall, wenn eine _id als String anstelle einer ObjectId übergeben wird.

db.users.findOne({ _id: ObjectId("6650f1e59d0a41a37c2d8011") });

Überprüfen Sie bei Löschvorgängen deletedCount. Wenn Sie ein gelöschtes Dokument erwartet haben und das Ergebnis deletedCount: 0 anzeigt, führen Sie nicht sofort eine umfassendere Löschung durch. Überprüfen Sie die Datenbank, Sammlung und den Filter erneut.

Wenn CRUD nicht ausreicht

Grundlegende CRUD-Befehle decken die meisten täglichen Datenarbeiten ab, aber einige Aufgaben erfordern leistungsstärkere Werkzeuge. Wenn Sie mehrere Sammlungen aktualisieren, die konsistent bleiben müssen, sehen Sie sich Transaktionen auf Replica Sets oder Sharded Clustern an. Wenn Sie Daten über viele Dokumente hinweg umstrukturieren, kann eine Aggregations-Pipeline klarer sein als eine lange Reihe von clientseitigen Schleifen. Wenn Sie Produktionsdaten migrieren, verwenden Sie ein Skript mit Protokollierung, Trockenlaufmodus, Backups und einem Rollback-Plan.

Für einmalige Operationen in mongosh halten Sie die Befehle lesbar. Ein ausgeklügelter Einzeiler ist schwieriger zu überprüfen und schwieriger zu beheben. In der Produktion sind langweilige Befehle in der Regel besser.

MongoDB CRUD-Befehle sind unkompliziert, sobald Sie sich an Dokumente, Filter und Update-Operatoren gewöhnt haben. Die Fähigkeit, die in der Praxis zählt, ist die Sorgfalt: Vorschau des Filters, Auswirkungen zählen, den engsten Schreibbefehl wählen, das Ergebnis lesen und genügend Kontext hinterlassen, damit die nächste Person verstehen kann, was sich geändert hat.