Multi-document transactions in MongoDB - Step-by-Step Execution

Concept Flow - Multi-document transactions

Start Transaction

↓

Execute Operation 1

↓

Execute Operation 2

↓

Commit Transaction?

No→Abort Transaction

Yes↓

End Transaction

This flow shows how multiple operations on different documents are grouped in a transaction, which either commits all changes or aborts all to keep data consistent.

Execution Sample

MongoDB

session.startTransaction();
db.collection1.insertOne({a:1});
db.collection2.updateOne({b:2}, {$set: {c:3}});
session.commitTransaction();

This code starts a transaction, inserts a document in one collection, updates a document in another, then commits all changes together.

Execution Table

Step	Action	Operation	State Before	State After	Notes
1	Start Transaction	Begin transaction session	No active transaction	Transaction active	Transaction session started
2	Insert Document	Insert {a:1} into collection1	collection1 has no {a:1}	collection1 has {a:1} (pending)	Insert staged, not visible outside transaction
3	Update Document	Update {b:2} in collection2 to set c=3	collection2 has {b:2, c:old}	collection2 has {b:2, c:3} (pending)	Update staged, not visible outside transaction
4	Commit Transaction	Commit all changes	Transaction active with staged changes	Changes visible in both collections	All changes applied atomically
5	End Transaction	Close transaction session	Transaction active	No active transaction	Transaction ended successfully

💡 Transaction commits successfully, making all changes visible together; if commit failed, all changes would be discarded.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
Transaction State	No transaction	Active	Active	Active	Committed	No transaction
collection1 documents	{}	{}	{a:1} (pending)	{a:1} (pending)	{a:1} (committed)	{a:1}
collection2 documents	{b:2, c:old}	{b:2, c:old}	{b:2, c:old}	{b:2, c:3} (pending)	{b:2, c:3} (committed)	{b:2, c:3}

Key Moments - 2 Insights

Why don't the inserted and updated documents appear immediately outside the transaction?

Because the changes are staged inside the transaction and only become visible after commit, as shown in steps 2 and 3 where state after shows 'pending' changes.

What happens if the commit fails or is aborted?

All staged changes are discarded and the database returns to the state before the transaction started, preventing partial updates. This is implied by the exit note and the commit step.

Visual Quiz - 3 Questions

Look at the execution table, what is the transaction state after step 3?

A No transaction

B Active with staged changes

C Committed

D Aborted

💡 Hint

Check the 'Transaction State' in variable_tracker after Step 3.

At which step do the changes become visible outside the transaction?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look at the 'State After' column in execution_table for when changes are 'committed'.

If the transaction is aborted after step 3, what happens to the inserted document in collection1?

A It becomes visible but uncommitted

B It is deleted

C It is never inserted

D It remains inserted

💡 Hint

Recall that uncommitted changes are not visible and are discarded on abort, as explained in key moments.

Concept Snapshot

Multi-document transactions group multiple operations into one atomic unit.
Start with startTransaction(), perform operations, then commitTransaction() to apply all changes.
If commit fails or abortTransaction() is called, all changes are discarded.
This ensures data consistency across multiple documents and collections.

Full Transcript

Multi-document transactions in MongoDB allow you to group several operations on different documents or collections into a single atomic unit. The process starts by calling startTransaction(), which opens a transaction session. Then, you perform your operations like inserts or updates. These changes are staged and not visible outside the transaction until you call commitTransaction(), which applies all changes together. If the commit fails or you call abortTransaction(), all staged changes are discarded, ensuring no partial updates occur. This mechanism helps keep your data consistent when multiple documents must be changed together.

Practice

1. What is the main purpose of using multi-document transactions in MongoDB?

easy

A. To create indexes automatically

B. To speed up single document queries

C. To ensure multiple document changes succeed or fail together

D. To backup the database

Solution

1. Step 1: Understand transaction purpose

   Transactions group multiple operations so they either all succeed or all fail, ensuring data consistency.

2. Step 2: Compare options

   Only To ensure multiple document changes succeed or fail together describes this behavior. Other options describe unrelated features.

3. Final Answer:

   To ensure multiple document changes succeed or fail together -> Option C

4. Quick Check:

   Transaction purpose = group changes atomically [OK]

Hint: Transactions group multiple changes to keep data consistent [OK]

Common Mistakes:

• Confusing transactions with indexing
• Thinking transactions speed up single queries
• Assuming transactions create backups

2. Which of the following is the correct way to start a transaction in a MongoDB session using the Node.js driver?

easy

A. db.transactionStart()

B. session.startTransaction()

C. session.begin()

D. start.sessionTransaction()

Solution

1. Step 1: Recall MongoDB transaction syntax

   The correct method to start a transaction on a session is startTransaction().

2. Step 2: Eliminate incorrect options

   Options A, B, and D are not valid MongoDB session methods.

3. Final Answer:

   session.startTransaction() -> Option B

4. Quick Check:

   Start transaction method = startTransaction() [OK]

Hint: Use session.startTransaction() to begin a transaction [OK]

Common Mistakes:

• Using incorrect method names like begin()
• Calling transaction methods on db instead of session
• Mixing method order or syntax

3. Consider this MongoDB transaction code snippet in Node.js:

const session = client.startSession();
session.startTransaction();
await collection1.insertOne({item: 'apple'}, {session});
await collection2.updateOne({item: 'banana'}, {$inc: {qty: 1}}, {session});
await session.commitTransaction();
session.endSession();
console.log('Transaction complete');

What will be printed if both operations succeed?

medium

A. Transaction complete

B. Transaction aborted

C. Error: session not started

D. No output

Solution

1. Step 1: Analyze transaction flow

   The code starts a session, begins a transaction, performs two operations, commits the transaction, ends the session, then logs a message.

2. Step 2: Determine output on success

   If both operations succeed and commitTransaction() completes without error, the console.log will print 'Transaction complete'.

3. Final Answer:

   Transaction complete -> Option A

4. Quick Check:

   Successful commit logs 'Transaction complete' [OK]

Hint: If commitTransaction succeeds, console logs 'Transaction complete' [OK]

Common Mistakes:

• Assuming commitTransaction logs automatically
• Confusing session start errors with commit success
• Ignoring async/await behavior

4. You wrote this MongoDB transaction code but it throws an error:

const session = client.startSession();
session.startTransaction;
await collection.insertOne({name: 'John'}, {session});
await session.commitTransaction();
session.endSession();

What is the error and how to fix it?

medium

A. insertOne does not accept session option

B. session.endSession() should be called before commitTransaction()

C. session.startSession() should be awaited

D. Missing parentheses on startTransaction; use session.startTransaction()

Solution

1. Step 1: Identify the syntax error

   The code calls session.startTransaction without parentheses, so the function is not executed.

2. Step 2: Correct the method call

   Add parentheses to call the function: session.startTransaction().

3. Final Answer:

   Missing parentheses on startTransaction; use session.startTransaction() -> Option D

4. Quick Check:

   Method calls need parentheses () [OK]

Hint: Always add () to call methods like startTransaction() [OK]

Common Mistakes:

• Forgetting parentheses on method calls
• Calling endSession before commitTransaction
• Thinking startSession is async and needs await

5. You want to update two collections atomically: deduct 10 from accounts.balance and add 10 to transactions.amount. Which transaction code snippet correctly ensures both updates succeed or fail together?

hard

A. const session = client.startSession();
session.startTransaction();
await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session});
await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session});
await session.commitTransaction();
session.endSession();

B. await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}});
await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}});

C. const session = client.startSession();
await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session});
await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session});
session.commitTransaction();
session.endSession();

D. const session = client.startSession();
session.startTransaction();
accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session});
transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session});
session.commitTransaction();
session.endSession();

Solution

1. Step 1: Check transaction start and commit

   const session = client.startSession(); session.startTransaction(); await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session}); await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session}); await session.commitTransaction(); session.endSession(); correctly calls startTransaction() and commitTransaction() on the session.

2. Step 2: Verify operations use session and await

   const session = client.startSession(); session.startTransaction(); await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session}); await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session}); await session.commitTransaction(); session.endSession(); uses await on both update operations and passes the session option, ensuring atomicity.

3. Step 3: Identify errors in other options

   await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}); await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}); lacks transaction usage. const session = client.startSession(); await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session}); await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session}); session.commitTransaction(); session.endSession(); misses startTransaction(). const session = client.startSession(); session.startTransaction(); accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session}); transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session}); session.commitTransaction(); session.endSession(); misses await on operations.

4. Final Answer:

   Option A code snippet -> Option A

5. Quick Check:

   Start, await ops with session, commit = correct transaction [OK]

Hint: Start transaction, await ops with session, then commit [OK]

Common Mistakes:

• Not awaiting async operations inside transaction
• Forgetting to start the transaction
• Running operations outside session context