Cum funcționează operațiile CRUD în MongoDB?

Question

Accepted Answer

**CRUD** (Create, Read, Update, Delete) operații în MongoDB utilizează metode pe colecții. Acestea funcționează cu documente și utilizează o sintaxă de interogare flexibilă, asemănătoare JSON — diferită de SQL dar conceptual similară.

## Create — inserare documente

```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 — interogare documente

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

Interogările utilizează un **document de filtru** (`{ field: value }`) care descrie ce să se potrivească, cu operatori (`$gt`, `$lt`, `$in`, etc.) pentru condiții. Proiecția (`{ name: 1 }`) selectează care câmpuri să se întoarcă.

## Update — modificare documente

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

Actualizările iau un **filtru** (care documente) și un **document de actualizare** folosind **operatori** ca `$set` (stabilire unui câmp), `$inc` (incrementare), `$push` (adăugare într-o matrice) — nu înlocuiți documentul întreg (cu excepția cazului în care este intenționat).

## Delete — ștergere documente

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

## De ce este important

Operațiile CRUD sunt fundamentul lucrului cu orice bază de date, deci înțelegerea modului în care funcționează în MongoDB este cunoaștere esențială de zi cu zi pentru a o utiliza.

Operațiile — **inserarea** documentelor (`insertOne`/`insertMany`), **interogarea** cu documente de filtru și operatori (`find`/`findOne` cu filtre `{ field: value }`, operatori de comparație ca `$gt`, și proiecții pentru selectarea câmpurilor), **actualizarea** cu filtre și operatori de actualizare (`updateOne`/`updateMany` cu `$set`, `$inc`, etc.), și **ștergerea** (`deleteOne`/`deleteMany`) — sunt modul în care aplicațiile creează, citesc, modifică și elimină date în MongoDB, ceea ce constituie esența majorității interacțiunilor cu baza de date.

Înțelegerea abordării distinctive a MongoDB este importantă: interogările utilizează un **document de filtru** (un obiect asemănător JSON care descrie ce să se potrivească, cu operatori) mai degrabă decât sintaxa `WHERE` din SQL, și actualizările utilizează **operatori de actualizare** (`$set` pentru a schimba câmpuri, `$inc` pentru a incrementa, `$push` pentru matrice) mai degrabă decât înlocuire completă a documentului — un model diferit dar ușor de învățat.

Deoarece CRUD este operația fundamentală și constantă în orice aplicație orientată pe date, și deoarece metodele CRUD ale MongoDB, interogările cu documente de filtru și operatorii de actualizare sunt modul în care interacționați cu baza de date zi de zi, înțelegerea operațiilor CRUD ale MongoDB — metodele, sintaxa interogării cu filtru/operator și operatorii de actualizare — este cunoaștere esențială și obligatorie pentru orice dezvoltare MongoDB, echivalentul cunoașterii SELECT/INSERT/UPDATE/DELETE pentru SQL și fundamentul practic pentru lucrul cu baza de date.