Hogyan működnek a CRUD műveletek a MongoDB-ben?

Question

Accepted Answer

**CRUD** (Create, Read, Update, Delete) műveletek a MongoDB-ben kollekciókon végrehajtott metódusokat használnak. Dokumentumokkal dolgoznak, és rugalmas, JSON-szerű lekérdezési szintaxist alkalmaznak — eltérő az SQL-től, de fogalmilag hasonló.

## Create — dokumentumok beszúrása

```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 — dokumentumok lekérdezése

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

A lekérdezések egy **szűrő dokumentumot** (`{ field: value }`) használnak, amely leírja, hogy mit keresünk, operátorokkal (`$gt`, `$lt`, `$in`, stb.) a feltételekhez. A vetítés (`{ name: 1 }`) meghatározza, mely mezőket adjuk vissza.

## Update — dokumentumok módosítása

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

A frissítések egy **szűrőt** (mely dokumentumok) és egy **frissítési dokumentumot** használnak, melyek **operátorokat** tartalmaznak, mint a `$set` (mező beállítása), `$inc` (inkrementálás), `$push` (hozzáadás tömbhöz) — nem cseréli le az egész dokumentumot (ha nem szándékos).

## Delete — dokumentumok eltávolítása

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

## Miért fontos

A CRUD műveletek bármilyen adatbázis-munka alapja, ezért a MongoDB-ben való működésük megértése napi szintű alapismeretekhez szükséges.

A műveletek — dokumentumok **beszúrása** (`insertOne`/`insertMany`), **lekérdezése** szűrő dokumentumokkal és operátorokkal (`find`/`findOne` `{ field: value }` szűrőkkel, összehasonlító operátorokkal, mint a `$gt`, és vetítésekkel a mezők kiválasztásához), **frissítése** szűrőkkel és frissítési operátorokkal (`updateOne`/`updateMany` `$set`, `$inc`, stb. használatával), és **törlése** (`deleteOne`/`deleteMany`) — így hozzák létre, olvassák, módosítják és távolítják el az adatokat a MongoDB-ben, ami az adatbázis-interakció lényege.

A MongoDB megkülönböztetett megközelítésének megértése fontos: a lekérdezések egy **szűrő dokumentumot** (JSON-szerű objektum, amely leírja a keresett feltételeket operátorokkal) használnak az SQL `WHERE` szintaxisa helyett, és a frissítések **frissítési operátorokat** (`$set` mezők megváltoztatásához, `$inc` inkrementáláshoz, `$push` tömbhöz) használnak teljes dokumentum-csere helyett — egy másik, de megtanulható modell.

Mivel a CRUD az alapvető, állandó művelet minden adatvezérelt alkalmazásban, és mivel a MongoDB CRUD metódusai, szűrő-dokumentum lekérdezései és frissítési operátorai az adatbázis-interakció napi szintű módszerei, a MongoDB CRUD műveleteinek megértése — a metódusok, a szűrő/operátor lekérdezési szintaxis és a frissítési operátorok — nélkülözhetetlen, kötelezően tudnivaló ismerete bármilyen MongoDB fejlesztésnek, az SQL-ben a SELECT/INSERT/UPDATE/DELETE ismeretének megfelelő gyakorlati alapja az adatbázissal való munkavégzéshez.