Hur infogar, uppdaterar och raderar du dokument?

Question

Accepted Answer

MongoDB ändrar data med **insert** (`insertOne`/`insertMany`), **update** (`updateOne`/`updateMany` med operatorer) och **delete** (`deleteOne`/`deleteMany`) metoder. Uppdateringar använder **update-operatorer** istället för att ersätta hela dokument — en viktig skillnad.

## 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 (ersätt inte hela 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
```

**Viktigt:** uppdateringar använder **operatorer** (`$set`, `$inc`, `$push`, osv.) för att ändra *specifika* fält. Utan en operator skulle du *ersätta hela dokumentet* — ett vanligt misstag:

```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 — infoga om inte funnet

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

## Varför det är viktigt

Insert-, update- och delete-operationer är hur applikationer **modifierar data** i MongoDB, vilket är grundläggande för alla datadrivna applikationer, så det är viktigt att förstå dem.

Att känna till metoderna (`insertOne`/`insertMany` för skapande, `updateOne`/`updateMany` för modifiering, `deleteOne`/`deleteMany` för radering) täcker grunderna.

Den **viktigaste och oftast missförstådda punkten** är att MongoDB-uppdateringar använder **update-operatorer** (`$set`, `$inc`, `$push`, `$pull`, osv.) för att ändra *specifika* fält — och kritiskt, **om man glömmer operatorn ersätts hela dokumentet** (ett känt misstag där `updateOne({...}, {age: 31})` raderar alla andra fält, och lämnar endast `age`), så att förstå att alltid använda `$set` (och andra operatorer) för uppdateringar på fältnivå är väsentligt för korrekthet.

Att känna till vanliga operatorer (`$set`, `$inc` för räknare, `$push`/`$pull`/`$addToSet` för arrayer — arrayoperatorer är särskilt relevanta med tanke på Mongos arrayrika dokument) är viktig daglig kunskap.

Att förstå **upsert** (`{ upsert: true }` — infoga om ingen matchning finns, Mongos insert-eller-uppdatera) är värdefullt för det vanliga insert-eller-uppdatera-mönstret.

Värt att notera är också faran med `deleteMany({})` (radera allt — liknar risken med saknade WHERE i SQL).

Since modifying data is fundamental, och eftersom Mongos operatorbaserade uppdateringar (med dokumentersättningsrisken), arrayoperatorer och upsert är hur du korrekt ändrar data, är det väsentligt att förstå insert/update/delete — särskilt den kritiska update-operatorn-skillnaden (undvik oavsiktlig dokumentersättning) — väsentlig, måste-veta-kunskap för all MongoDB-utveckling, där operatorrisken i synnerhet är en frekvent källa till verkliga buggar.