Multi-document transactions in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this multi-document transaction commit?

Consider a MongoDB transaction that inserts two documents into two different collections and then commits. What will be the state of the collections after the commit?

MongoDB

const session = client.startSession();
session.startTransaction();
try {
  await db.collection('users').insertOne({ _id: 1, name: 'Alice' }, { session });
  await db.collection('orders').insertOne({ _id: 101, item: 'Book' }, { session });
  await session.commitTransaction();
} catch (e) {
  await session.abortTransaction();
} finally {
  session.endSession();
}

// What documents exist now in 'users' and 'orders' collections?

A Both collections have the new documents inserted by the transaction.

B Only the 'users' collection has the new document; 'orders' is empty.

C Neither collection has the new documents because transactions are not supported.

D Only the 'orders' collection has the new document; 'users' is empty.

💡 Hint

Think about what commitTransaction() does after successful operations inside a transaction.

When a multi-document transaction commits successfully, all operations inside it become visible atomically. So both documents are inserted.

🧠 Conceptual

intermediate

Which statement about MongoDB multi-document transactions is true?

Select the correct statement about multi-document transactions in MongoDB.

A Transactions automatically retry on network errors without developer intervention.

B Transactions lock the entire database during their execution.

C Transactions can span multiple collections and databases within the same replica set.

D Transactions are supported only on standalone MongoDB servers.

💡 Hint

Think about the scope and environment where transactions work in MongoDB.

MongoDB supports multi-document transactions across multiple collections and databases but only within a replica set or sharded cluster.

🔧 Debug

advanced

Why does this transaction abort with an error?

Examine the following MongoDB transaction code snippet. Why does it abort with a write conflict error?

MongoDB

const session = client.startSession();
session.startTransaction();
try {
  await db.collection('inventory').updateOne({ _id: 1 }, { $inc: { qty: -1 } }, { session });
  await db.collection('inventory').updateOne({ _id: 1 }, { $inc: { qty: -1 } }, { session });
  await session.commitTransaction();
} catch (e) {
  await session.abortTransaction();
  throw e;
} finally {
  session.endSession();
}

A Transactions cannot update documents in the same collection twice.

B The commitTransaction() method was called before any operations.

C The session was not properly started before the transaction.

D The transaction tries to update the same document twice causing a write conflict.

💡 Hint

Consider what happens when two operations inside a transaction modify the same document.

Updating the same document twice in a transaction can cause a write conflict if the document version changes between operations.

📝 Syntax

advanced

Which option correctly starts a multi-document transaction in MongoDB?

Choose the correct syntax to start a multi-document transaction using the MongoDB Node.js driver.

A

const session = client.startSession();
session.startTransaction();

B const session = client.startTransaction();

C client.startSession().startTransaction();

D const session = client.transaction(); session.begin();

💡 Hint

Remember the two-step process: start a session, then start a transaction on that session.

You must first start a session, then call startTransaction() on that session object.

❓ optimization

expert

How to optimize a multi-document transaction to reduce lock contention?

You have a MongoDB multi-document transaction that updates multiple documents across collections. Which approach best reduces lock contention and improves performance?

A Increase the transaction timeout to allow more time for operations to complete.

B Keep the transaction as short as possible by minimizing the number of operations inside it.

C Use multiple nested transactions to isolate updates per collection.

D Disable journaling to speed up writes during the transaction.

💡 Hint

Think about how long locks are held during a transaction.

Shorter transactions hold locks for less time, reducing contention and improving concurrency.

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