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.