Wie fügen Sie Dokumente ein, aktualisieren und löschen diese?

Question

Accepted Answer

MongoDB ändert Daten mit **Insert**-Methoden (`insertOne`/`insertMany`), **Update**-Methoden (`updateOne`/`updateMany` mit Operatoren) und **Delete**-Methoden (`deleteOne`/`deleteMany`). Updates verwenden **Update-Operatoren** statt ganzer Dokumente zu ersetzen — eine wichtige Unterscheidung.

## Insert

```js
db.users.insertOne({ name: "Ann", age: 30 });          // → returns the inserted _id
db.users.insertMany([{ name: "Bob" }, { name: "Carol" }]);   // bulk insert (efficient)
```

## Update mit Operatoren (nicht das ganze Dokument ersetzen)

```js
// updateOne — filter (which doc) + update (with OPERATORS)
db.users.updateOne(
  { name: "Ann" },
  { $set: { age: 31, status: "active" } }   // $set: change specific fields
);

// common update operators
{ $set: { field: value } }       // set/change a field
{ $unset: { field: "" } }         // remove a field
{ $inc: { count: 1 } }            // increment a number
{ $push: { tags: "new" } }        // add to an array
{ $pull: { tags: "old" } }        // remove from an array
{ $addToSet: { tags: "x" } }      // add to array only if not present
```

```js
db.users.updateMany({ active: false }, { $set: { archived: true } });  // update all matching
```

**Wichtig:** Updates verwenden **Operatoren** (`$set`, `$inc`, `$push`, usw.) um *spezifische* Felder zu ändern. Ohne einen Operator würde man das *gesamte Dokument ersetzen* — eine häufige Falle:

```js
// ❌ this REPLACES the whole document (loses other fields!)
db.users.updateOne({ name: "Ann" }, { age: 31 });   // Ann now has ONLY age!
// ✅ use $set to change just the field
db.users.updateOne({ name: "Ann" }, { $set: { age: 31 } });
```

## Delete

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

## Upsert — einfügen, wenn nicht vorhanden

```js
db.users.updateOne(
  { email: "ann@x.com" },
  { $set: { name: "Ann" } },
  { upsert: true }            // if no match, INSERT a new document
);
```

## Warum es wichtig ist

Insert-, Update- und Delete-Operationen sind die Art und Weise, wie Anwendungen **Daten in MongoDB ändern**, fundamental für jede datengesteuerte Anwendung, daher ist das Verständnis dieser Operationen essentiell.

Die Kenntnis der Methoden (`insertOne`/`insertMany` zum Erstellen, `updateOne`/`updateMany` zum Ändern, `deleteOne`/`deleteMany` zum Löschen) deckt die Grundlagen ab.

Der **wichtigste und am häufigsten falsch verstandene Punkt** ist, dass MongoDB-Updates **Update-Operatoren** (`$set`, `$inc`, `$push`, `$pull`, usw.) verwenden, um *spezifische* Felder zu ändern — und kritisch: **das Vergessen des Operators ersetzt das gesamte Dokument** (eine berüchtigte Falle, bei der `updateOne({...}, {age: 31})` alle anderen Felder löscht und nur `age` übrig bleibt), daher ist das Verständnis, immer `$set` (und die anderen Operatoren) für Updates auf Feldebene zu verwenden, essentiell für Korrektheit.

Die Kenntnis der häufigen Operatoren (`$set`, `$inc` für Zähler, `$push`/`$pull`/`$addToSet` für Arrays — Array-Operatoren sind besonders relevant angesichts von Mongodbś Array-reichen Dokumenten) ist wichtiges alltägliches Wissen.

Das Verständnis von **Upsert** (`{ upsert: true }` — einfügen, wenn keine Übereinstimmung existiert, Mongodbś Insert-or-Update) ist wertvoll für das häufige Insert-or-Update-Muster.

Erwähnenswert ist auch die Gefahr von `deleteMany({})` (alles löschen — ähnlich der fehlenden-WHERE-Gefahr in SQL).

Da das Ändern von Daten fundamental ist und da Mongodbś Operator-basierte Updates (mit der Dokument-Ersetzungs-Falle), Array-Operatoren und Upsert die Art sind, wie man Daten korrekt ändert, ist das Verständnis von Insert/Update/Delete — besonders die kritische Update-Operator-Unterscheidung (Vermeidung von versehentlichem Dokument-Ersetzen) — essentiell, absolutes Muss-Wissen für jede MongoDB-Entwicklung, wobei die Operator-Falle insbesondere eine häufige Quelle echter Bugs ist.