Cum funcționează tranzacțiile în MongoDB?

Question

Accepted Answer

MongoDB suportă **tranzacții ACID multi-document** (începând cu v4.0 pentru replica sets, v4.2 pentru sharded clusters) — grupând operații pe mai multe documente/colecții, astfel încât fie toate reușesc, fie toate eșuează. Cu toate acestea, modelul de document al MongoDB face adesea tranzacțiile *inutile* prin operații atomice pe un singur document.

## Operațiile pe un singur document sunt deja atomice

```text
KEY POINT: operations on a SINGLE document are ALWAYS atomic in MongoDB.
→ Because related data is often EMBEDDED in one document, many operations that would
  need a transaction in SQL are a single atomic document update in MongoDB.
→ Good schema design (embedding) often eliminates the NEED for multi-doc transactions.
```

```js
// updating a document and its embedded array atomically — NO transaction needed
db.accounts.updateOne(
  { _id: id },
  { $inc: { balance: -100 }, $push: { transactions: { amount: -100 } } }
);  // atomic — both changes succeed or fail together (single document)
```

## Tranzacții multi-document (când sunt cu adevărat necesare)

```js
// for operations across MULTIPLE documents/collections that must be atomic
const session = db.getMongo().startSession();
session.startTransaction();
try {
  db.accounts.updateOne({ _id: 1 }, { $inc: { balance: -100 } }, { session });
  db.accounts.updateOne({ _id: 2 }, { $inc: { balance: 100 } }, { session });
  session.commitTransaction();        // both succeed together
} catch (e) {
  session.abortTransaction();          // or both roll back
} finally {
  session.endSession();
}
```

Tranzacțiile multi-document (folosind o sesiune) oferă garanții ACID pe mai multe documente — pentru cazuri precum transferul între documente de conturi separate.

## Utilizează tranzacțiile cu moderație

```text
✓ Transactions are available and provide ACID across documents WHEN NEEDED
✗ But they have PERFORMANCE COSTS (overhead, locking) — don't overuse them
→ PREFER good schema design (embedding related data) so single-document atomic
  operations suffice. Use multi-document transactions only when data genuinely
  spans documents and must be consistent (e.g. money transfers between accounts).
→ Requires a replica set (not standalone).
```

## De ce este important

Înțelegerea tranzacțiilor MongoDB — și mai ales când sunt necesare — este importantă pentru a asigura coerența datelor în aplicațiile MongoDB, deci este o cunoaștere valoroasă pentru construirea de sisteme corecte.

Cel mai important insight este că **operațiile pe un singur document sunt întotdeauna atomice** în MongoDB, și deoarece modelul de document încurajează **încorporarea datelor conexe într-un singur document**, multe operații care ar necesita o tranzacție într-o bază de date relațională (unde datele conexe sunt împărțite între tabele) sunt o **actualizare atomică a unui singur document** în MongoDB — deci **o bună proiectare a schemei eliminate adesea necesitatea tranzacțiilor multi-document**.

Acesta este un punct conceptual cheie: atomicitatea per-document a MongoDB, combinată cu încorporarea, tratează multe necesități de coerență fără tranzacții.

Înțelegerea că MongoDB **suportă cu adevărat tranzacții ACID multi-document** (de la v4.0+) pentru cazuri în care operațiile se desfășoară cu adevărat pe mai multe documente/colecții (cum ar fi transferul între documente de conturi separate) este importantă — sunt disponibile când sunt cu adevărat necesare, oferind garanții all-or-nothing.

La fel de important este îndrumarea de a **utiliza tranzacțiile cu moderație**: au costuri de performanță (overhead, blocări), deci abordarea preferată este o bună proiectare a schemei (încorporare), astfel încât operațiile atomice pe un singur document să fie suficiente, rezervând tranzacțiile multi-document pentru necesitățile de coerență genuine pe mai multe documente.

Înțelegerea acestui fapt — atomicitatea pe un singur document, că încorporarea adesea elimină necesitatea tranzacțiilor, că tranzacțiile multi-document există pentru când sunt cu adevărat necesare, și preferința pentru design în loc de tranzacții — reflectă o judecată solidă a MongoDB.

Deoarece coerența datelor este critică și abordarea MongoDB (atomicitate pe document + tranzacții opționale) diferă de modelul transacțional al SQL, înțelegerea tranzacțiilor MongoDB — în special că operațiile pe un singur document sunt atomice, încorporarea reduce necesitatea tranzacțiilor, și tranzacțiile multi-document sunt disponibile dar ar trebui utilizate cu judecată — este o cunoaștere valoroasă și importantă pentru asigurarea coherenței corect și eficient în aplicațiile MongoDB, un subiect care reflectă înțelegerea modelului de coerență al MongoDB și a practicilor de proiectare bună.