Wie funktionieren CRUD-Operationen in MongoDB?

Question

Accepted Answer

**CRUD** (Create, Read, Update, Delete) sind Operationen in MongoDB, die Methoden auf Collections verwenden. Sie arbeiten mit Dokumenten und nutzen eine flexible, JSON-ähnliche Abfragesyntax — anders als SQL, aber konzeptionell ähnlich.

## Erstellen — Dokumente einfügen

```js
db.users.insertOne({ name: "Ann", age: 30 });          // insert one document
db.users.insertMany([                                   // insert multiple
  { name: "Bob", age: 25 },
  { name: "Carol", age: 28 }
]);
// each gets an auto-generated _id if not provided
```

## Lesen — Dokumente abfragen

```js
db.users.find();                              // all documents
db.users.find({ age: 30 });                   // WHERE age = 30 (a query filter object)
db.users.find({ age: { $gt: 25 } });          // age > 25 ($gt operator)
db.users.findOne({ name: "Ann" });            // the first match
db.users.find({ active: true }, { name: 1 }); // projection — return only the name field
```

Abfragen verwenden ein **Filterdokument** (`{ field: value }`), das beschreibt, was zu finden ist, mit Operatoren (`$gt`, `$lt`, `$in`, etc.) für Bedingungen. Projektion (`{ name: 1 }`) wählt aus, welche Felder zurückgegeben werden.

## Aktualisieren — Dokumente ändern

```js
// updateOne/updateMany with UPDATE OPERATORS ($set, $inc, etc.)
db.users.updateOne(
  { name: "Ann" },                  // filter — which document
  { $set: { age: 31 } }              // update — $set changes a field
);
db.users.updateMany(
  { active: false },
  { $set: { status: "inactive" } }   // update all matching
);
db.users.updateOne({ name: "Ann" }, { $inc: { loginCount: 1 } });  // increment
```

Aktualisierungen benötigen einen **Filter** (welche Dokumente) und ein **Aktualisierungsdokument** mit **Operatoren** wie `$set` (ein Feld setzen), `$inc` (erhöhen), `$push` (zu einem Array hinzufügen) — Sie ersetzen nicht das ganze Dokument (falls nicht beabsichtigt).

## Löschen — Dokumente entfernen

```js
db.users.deleteOne({ name: "Ann" });          // delete the first match
db.users.deleteMany({ active: false });        // delete all matching
```

## Warum es wichtig ist

CRUD-Operationen sind die Grundlage für die Arbeit mit jeder Datenbank, daher ist das Verständnis, wie sie in MongoDB funktionieren, wesentliches Alltagswissen für die Nutzung.

Die Operationen — **Einfügen** von Dokumenten (`insertOne`/`insertMany`), **Abfragen** mit Filterdokumenten und Operatoren (`find`/`findOne` mit `{ field: value }` Filtern, Vergleichsoperatoren wie `$gt` und Projektionen zur Feldauswahl), **Aktualisieren** mit Filtern und Aktualisierungsoperatoren (`updateOne`/`updateMany` mit `$set`, `$inc`, etc.) und **Löschen** (`deleteOne`/`deleteMany`) — sind die Art, wie Anwendungen Daten in MongoDB erstellen, lesen, ändern und entfernen, was der Kern der meisten Datenbankinteraktionen ist.

MongoDBs charakteristischen Ansatz zu verstehen ist wichtig: Abfragen verwenden ein **Filterdokument** (ein JSON-ähnliches Objekt, das beschreibt, was zu finden ist, mit Operatoren) statt SQLs `WHERE`-Syntax, und Aktualisierungen verwenden **Aktualisierungsoperatoren** (`$set` zum Ändern von Feldern, `$inc` zum Erhöhen, `$push` für Arrays) statt vollständigem Dokumentersatz — ein anderes, aber erlernbares Modell.

Da CRUD die grundlegende, ständige Operation in jeder datengesteuerten Anwendung ist und MongoDBs CRUD-Methoden, Filter-Dokument-Abfragen und Aktualisierungsoperatoren die Art sind, wie Sie täglich mit der Datenbank interagieren, ist das Verständnis von MongoDB CRUD-Operationen — die Methoden, die Filter-/Operator-Abfragesyntax und die Aktualisierungsoperatoren — wesentliches, unverzichtbares Wissen für jede MongoDB-Entwicklung, das Äquivalent zum Kennen von SELECT/INSERT/UPDATE/DELETE für SQL und die praktische Grundlage für die Arbeit mit der Datenbank.