DevOps Wissensdatenbank
DevOps Wissensdatenbank

MongoDB CRUD-Operationen meistern: Ein praktischer Befehlsleitfaden

Schöpfen Sie das Potenzial von MongoDB aus mit diesem praktischen Befehlsleitfaden zu den wichtigsten CRUD-Operationen. Erfahren Sie, wie Sie Ihre Daten mithilfe der Befehle `insert`, `find`, `update` und `delete` effizient verwalten. Dieser Artikel bietet klare Erklärungen, Praxisbeispiele und Best Practices für das Erstellen, Lesen, Aktualisieren und Entfernen von Dokumenten in Ihren MongoDB Collections. Ideal für Entwickler und Administratoren – es ist Ihre zentrale Ressource zur Beherrschung der MongoDB-Datenmanipulation.

39 Aufrufe

MongoDB CRUD-Operationen meistern: Ein praktischer Befehlsleitfaden

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

Dieser umfassende Leitfaden führt Sie durch die zentralen MongoDB-Befehle zur Durchführung von CRUD-Operationen. Wir behandeln die Befehle insert, find, update und delete mit praktischen, leicht verständlichen Beispielen, um Sie in die Lage zu versetzen, Ihre Daten effizient zu verwalten. Am Ende dieses Artikels werden Sie ein solides Verständnis dafür haben, wie Sie effektiv und sicher mit Ihren MongoDB-Collections interagieren können.

Voraussetzungen

Bevor Sie in die Befehle eintauchen, stellen Sie sicher, dass Sie Folgendes haben:

  • MongoDB installiert und läuft: 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-Oberfläche für MongoDB.

Verbindung zu MongoDB und Auswahl einer Datenbank

Um zu beginnen, öffnen Sie Ihr Terminal oder die Eingabeaufforderung und verbinden Sie sich mit Ihrer MongoDB-Instanz mit mongosh:

mongosh

Sobald Sie verbunden sind, befinden Sie sich in der Standarddatenbank test. Um zu einer anderen Datenbank zu wechseln oder eine neue zu erstellen, verwenden Sie den Befehl use:

use myDatabase;

Wenn myDatabase nicht existiert, erstellt MongoDB diese implizit, sobald Sie Ihr erstes Dokument in einer Collection darin einfügen.

Erstellungsoperationen (Insert)

Erstellungsoperationen beinhalten das Hinzufügen neuer Dokumente zu einer Collection. MongoDB bietet Methoden zum Einfügen einzelner oder mehrerer Dokumente.

1. db.collection.insertOne()

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

// Wähle eine Collection namens 'users'
db.users.insertOne({
  name: "Alice Smith",
  age: 30,
  city: "New York",
  email: "[email protected]",
  interests: ["reading", "hiking"]
});

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

2. db.collection.insertMany()

Verwenden Sie diese Methode, um mehrere Dokumente in einer einzigen Operation in eine Collection 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.

Leseoperationen (Find)

Leseoperationen beinhalten das Abfragen von Dokumenten aus einer Collection. Die Methode find() ist Ihr primäres Werkzeug dafür.

1. db.collection.find()

a. Alle Dokumente finden

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

db.users.find();

b. Dokumente mit einem Abfragefilter finden

Übergeben Sie ein Abfragedokument an find(), um Kriterien für die Auswahl der Dokumente festzulegen. Dies fungiert als WHERE-Klausel in SQL.

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

// Finde Benutzer, die älter als 25 sind
db.users.find({ age: { $gt: 25 } });

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

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

// Finde Benutzer, deren Interessen SOWOHL 'reading' ALS AUCH 'hiking' enthalten
db.users.find({ interests: { $all: ["reading", "hiking"] } });

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

Allgemeine Abfrageoperatoren:
* $eq: Gleich (Standard, wenn kein Operator angegeben ist)
* $ne: Nicht gleich
* $gt: Größer als
* $gte: Größer oder gleich
* $lt: Kleiner als
* $lte: Kleiner oder gleich
* $in: Stimmt mit einem der in einem Array angegebenen Werte überein
* $nin: Stimmt mit keinem der in einem Array angegebenen Werte überein
* $and, $or, $not, $nor: Logische Operatoren

c. Projektion: Auswahl spezifischer Felder

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.

// Gib nur den Namen und die E-Mail zurück, schließe _id aus
db.users.find({ city: "New York" }, { name: 1, email: 1, _id: 0 });

d. Sortieren, Begrenzen und Überspringen

Das Verketten von Methoden ermöglicht komplexere Abfragen:

// Nach Alter in absteigender Reihenfolge sortieren (1 für aufsteigend, -1 für absteigend)
db.users.find().sort({ age: -1 });

// Ergebnisse auf 2 Dokumente beschränken
db.users.find().limit(2);

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

// Operationen kombinieren: Finde Benutzer aus New York, sortiere nach Alter, überspringe 1, beschränke auf 1
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" });

Aktualisierungsoperationen

Aktualisierungsoperationen modifizieren vorhandene Dokumente in einer Collection. Sie können ein einzelnes Dokument, mehrere Dokumente aktualisieren oder sogar ein gesamtes Dokument ersetzen.

1. db.collection.updateOne()

Aktualisiert ein einzelnes Dokument, das den Filterkriterien entspricht.

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

2. db.collection.updateMany()

Aktualisiert alle Dokumente, die den Filterkriterien entsprechen.

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

// Füge 'reading' zu den Interessen von Benutzern hinzu, die es noch nicht haben
db.users.updateMany(
  {}, // Auf alle Dokumente anwenden
  { $addToSet: { interests: "reading" } }
);

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

Allgemeine 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 angegebenen Betrag.
* $unset: Entfernt ein Feld aus einem Dokument.
* $push: Hängt einen Wert an ein Array-Feld an.
* $pull: Entfernt alle Vorkommen eines Werts oder von Werten, die mit einer angegebenen Abfrage übereinstimmen, aus einem Array.
* $addToSet: Fügt einem Array einen Wert hinzu, nur wenn der Wert noch nicht 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.

// Ersetze das Dokument von Bob Johnson vollständig
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
);

Löschoperationen

Löschoperationen entfernen Dokumente aus einer Collection. Seien Sie bei Löschoperationen äußerst vorsichtig, da sie unumkehrbar sind.

1. db.collection.deleteOne()

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

// Lösche den Benutzer namens 'Robert Johnson' (zuvor 'Bob Johnson')
db.users.deleteOne({ name: "Robert Johnson" });

2. db.collection.deleteMany()

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

// Lösche alle Benutzer aus London
db.users.deleteMany({ city: "London" });

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

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

3. db.collection.drop()

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

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

Warnung: Das Löschen einer Collection ist eine sehr destruktive Operation. Stellen Sie sicher, dass Sie über ordnungsgemäße 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 Leseoperationen 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 die Netzwerkauslastung und den Speicherverbrauch.
  • Batch-Operationen: Wenn Sie viele Dokumente einfügen, aktualisieren oder löschen, verwenden Sie insertMany(), updateMany() und deleteMany() anstelle einzelner Operationen, um den Overhead zu reduzieren.
  • Operatoren verstehen: Machen Sie sich mit der reichhaltigen Auswahl an Abfrage- und Update-Operatoren von MongoDB vertraut. Sie bieten leistungsstarke Möglichkeiten zur Datenmanipulation.
  • Fehlerbehandlung: Implementieren Sie in einer Produktionsanwendung immer eine robuste Fehlerbehandlung für Ihre Datenbankoperationen.
  • Schema-Design: Obwohl MongoDB schemalos ist, ist ein durchdachtes Schema-Design entscheidend für effiziente Abfragen und Datenkonsistenz.

Fazit

Die Beherrschung der CRUD-Operationen von MongoDB ist grundlegend für eine effektive Datenverwaltung und Anwendungsentwicklung. Dieser Leitfaden hat Ihnen eine praktische Einführung in die wesentlichen Befehle insert, find, update und delete gegeben, komplett mit Beispielen und Best Practices.

Indem Sie verstehen, wie Dokumente erstellt, gelesen, aktualisiert und gelöscht werden, haben Sie die Kernkompetenzen erworben, um effizient mit Ihren MongoDB-Datenbanken zu interagieren. Üben Sie diese Befehle weiterhin und erkunden Sie fortgeschrittenere Funktionen wie Aggregationspipelines, Transaktionen und Indexierungsstrategien, um Ihre MongoDB-Kenntnisse weiter zu vertiefen.