Hvordan fungerer CRUD-operasjoner i MongoDB?

Question

Accepted Answer

**CRUD** (Create, Read, Update, Delete) operasjoner i MongoDB bruker metoder på samlinger. De fungerer med dokumenter og bruker en fleksibel, JSON-lignende spørringssyntaks — annerledes enn SQL, men konseptuelt lik.

## Create — sett inn dokumenter

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

## Read — spør dokumenter

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

Spørringer bruker et **filterdokument** (`{ field: value }`) som beskriver hva som skal samsvare, med operatorer (`$gt`, `$lt`, `$in`, osv.) for betingelser. Projeksjon (`{ name: 1 }`) velger hvilke felt som skal returneres.

## Update — endre dokumenter

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

Oppdateringer tar et **filter** (hvilke dokumenter) og et **oppdateringsdokument** som bruker **operatorer** som `$set` (sett et felt), `$inc` (øk), `$push` (legg til i en matrise) — du erstatter ikke hele dokumentet (med mindre det er tilsiktet).

## Delete — fjern dokumenter

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

## Hvorfor det betyr noe

CRUD-operasjoner er grunnlaget for å arbeide med enhver database, så det er avgjørende kunnskaper for dagligdagse bruk av MongoDB å forstå hvordan de fungerer.

Operasjonene — **innsetting** av dokumenter (`insertOne`/`insertMany`), **spørring** med filterdokumenter og operatorer (`find`/`findOne` med `{ field: value }` filtre, sammenligningsoperatorer som `$gt`, og projeksjoner for å velge felt), **oppdatering** med filtre og oppdateringsoperatorer (`updateOne`/`updateMany` med `$set`, `$inc`, osv.), og **sletting** (`deleteOne`/`deleteMany`) — er hvordan applikasjoner lager, leser, endrer og fjerner data i MongoDB, noe som er kjernen i det meste databaseinteraksjonen.

Å forstå Mongodbs særegne tilnærming er viktig: spørringer bruker et **filterdokument** (et JSON-lignende objekt som beskriver hva som skal samsvare, med operatorer) i stedet for SQLs `WHERE`-syntaks, og oppdateringer bruker **oppdateringsoperatorer** (`$set` for å endre felt, `$inc` for å øke, `$push` for matriser) i stedet for full-dokumentutskifting — en annerledes, men lærbar modell.

Siden CRUD er den grunnleggende, konstante operasjonen i enhver datadrevet applikasjon, og siden Mongodbs CRUD-metoder, filterdokument-spørringer og oppdateringsoperatorer er hvordan du samhandler med databasen dag til dag, er det avgjørende, obligatorisk kunnskap for all MongoDB-utvikling å forstå MongoDB CRUD-operasjoner — metodene, filter-/operatørspørringssyntaksen og oppdateringsoperatorene — det tilsvarer å kjenne SELECT/INSERT/UPDATE/DELETE for SQL og er det praktiske grunnlaget for å arbeide med databasen.