Hvordan setter du inn, oppdaterer og sletter dokumenter?

Question

Accepted Answer

MongoDB endrer data med **insert** (`insertOne`/`insertMany`), **update** (`updateOne`/`updateMany` med operatorer), og **delete** (`deleteOne`/`deleteMany`) metoder. Oppdateringer bruker **update-operatorer** i stedet for å erstatte hele dokumenter — en viktig distinksjon.

## Insert

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

## Update med operatorer (erstatt ikke hele dokumentet)

```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
```

**Viktig:** oppdateringer bruker **operatorer** (`$set`, `$inc`, `$push`, osv.) for å endre *spesifikke* felt. Uten en operator vil du *erstatte hele dokumentet* — en vanlig felle:

```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 — sett inn hvis ikke funnet

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

## Hvorfor det er viktig

Insert-, update- og delete-operasjoner er hvordan applikasjoner **endrer data** i MongoDB, og er fundamentale for enhver datadrevet applikasjon, så å forstå dem er essensielt hverdagskunnskaper.

Å kjenne metodene (`insertOne`/`insertMany` for å lage, `updateOne`/`updateMany` for å endre, `deleteOne`/`deleteMany` for å fjerne) dekker det grunnleggende.

Det **viktigste og mest vanlig misforståtte punktet** er at MongoDB-oppdateringer bruker **update-operatorer** (`$set`, `$inc`, `$push`, `$pull`, osv.) for å endre *spesifikke* felt — og kritisk sett, **hvis du glemmer operatoren erstatter du hele dokumentet** (en beryktet felle der `updateOne({...}, {age: 31})` sletter alle andre felt, og etterlater bare `age`), så å forstå at du alltid må bruke `$set` (og de andre operatorene) for felt-nivå oppdateringer er essensielt for korrekthet.

Å kjenne de vanlige operatorene (`$set`, `$inc` for tellere, `$push`/`$pull`/`$addToSet` for arrays — array-operatorer er særlig relevant gitt MongoDBs array-rike dokumenter) er viktig hverdagskunnskaper.

Å forstå **upsert** (`{ upsert: true }` — sett inn hvis ingen match finnes, MongoDBs insert-eller-update) er verdifullt for det vanlige insert-eller-update mønsteret.

Vert å merke seg er også faren ved `deleteMany({})` (slette alt — lignende som missing-WHERE faren i SQL).

Fordi endring av data er fundamental, og fordi MongoDBs operator-baserte oppdateringer (med dokument-erstatnings fallen), array-operatorer, og upsert er hvordan du korrekt endrer data, er å forstå insert/update/delete — spesielt den kritiske update-operator distinksjonen (unngå utilsiktet dokument-erstatning) — essensielt, must-know kunnskaper for enhver MongoDB-utvikling, der operator-fallen særlig er en hyppig kilde til ekte bugs.