Hoe werken CRUD-bewerkingen in MongoDB?

Question

Accepted Answer

**CRUD** (Create, Read, Update, Delete) bewerkingen in MongoDB gebruiken methodes op collections. Ze werken met documenten en gebruiken een flexibele, JSON-achtige querysyntax — anders dan SQL maar conceptueel vergelijkbaar.

## Create — documenten invoegen

```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 — documenten opvragen

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

Queries gebruiken een **filterdocument** (`{ field: value }`) dat beschrijft wat overeenkomt, met operatoren (`$gt`, `$lt`, `$in`, enz.) voor voorwaarden. Projectie (`{ name: 1 }`) selecteert welke velden worden geretourneerd.

## Update — documenten wijzigen

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

Updates nemen een **filter** (welke documenten) en een **updatedocument** met **operatoren** zoals `$set` (veld instellen), `$inc` (verhogen), `$push` (toevoegen aan array) — je vervangt niet het hele document (tenzij bedoeld).

## Delete — documenten verwijderen

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

## Waarom het belangrijk is

CRUD-bewerkingen vormen de basis van werken met elke database, dus inzicht in hoe ze werken in MongoDB is essentieel, dagelijks gebruikte kennis voor het gebruik ervan.

De bewerkingen — **invoegen** van documenten (`insertOne`/`insertMany`), **opvragen** met filterdocumenten en operatoren (`find`/`findOne` met `{ field: value }` filters, vergelijkingsoperatoren zoals `$gt`, en projecties om velden te selecteren), **bijwerken** met filters en update-operatoren (`updateOne`/`updateMany` met `$set`, `$inc`, enz.), en **verwijderen** (`deleteOne`/`deleteMany`) — zijn hoe applicaties gegevens in MongoDB maken, lezen, wijzigen en verwijderen, wat de kern is van de meeste databaseinteractie.

Inzicht in MongoDB's onderscheidende aanpak is belangrijk: queries gebruiken een **filterdocument** (een JSON-achtig object dat beschrijft wat overeenkomt, met operatoren) in plaats van SQL's `WHERE`-syntaxis, en updates gebruiken **update-operatoren** (`$set` om velden te wijzigen, `$inc` om te verhogen, `$push` voor arrays) in plaats van volledige documentvervanging — een ander maar leerzaam model.

Omdat CRUD de fundamentele, constante bewerking is in elke datagestuurde applicatie, en omdat MongoDB's CRUD-methodes, filterdocument-querysyntax en update-operatoren de manier zijn waarop je dagelijks met de database communiceert, is inzicht in MongoDB CRUD-bewerkingen — de methodes, de filter-/operatorquerysyntax en de update-operatoren — essentieel, onmisbare kennis voor elke MongoDB-ontwikkeling, het equivalent van SELECT/INSERT/UPDATE/DELETE kennen voor SQL en de praktische basis voor werken met de database.