Session and transaction syntax in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this MongoDB transaction commit?

Consider the following MongoDB transaction code snippet. What will be the output after the transaction commits successfully?

MongoDB

const session = client.startSession();
let result;
try {
  session.startTransaction();
  const coll = client.db('shop').collection('orders');
  result = await coll.insertOne({item: 'book', qty: 3}, {session});
  await session.commitTransaction();
} catch (e) {
  await session.abortTransaction();
} finally {
  await session.endSession();
}
return result.insertedId;

A Undefined because session is not passed

B null

C Throws a SyntaxError

D ObjectId of the inserted document

💡 Hint

Think about what insertOne returns when used inside a transaction with a session.

The insertOne method returns a result object containing insertedId when the insert succeeds inside a transaction. The session is correctly passed, so the transaction commits and returns the inserted document's ObjectId.

📝 Syntax

intermediate

Which option correctly starts a MongoDB session and transaction?

Select the code snippet that correctly starts a session and a transaction in MongoDB.

A const session = client.startSession(); session.begin();

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

C const session = client.sessionStart(); session.beginTransaction();

D const session = client.newSession(); session.startTransaction();

💡 Hint

Check the official MongoDB Node.js driver method names for sessions and transactions.

The correct methods are startSession() to start a session and startTransaction() to begin a transaction. Other options use incorrect method names.

🔧 Debug

advanced

Why does this MongoDB transaction code throw an error?

Given the code below, why does it throw an error when trying to commit the transaction? const session = client.startSession(); session.startTransaction(); const coll = client.db('test').collection('users'); await coll.insertOne({name: 'Alice'}); await session.commitTransaction(); session.endSession();

A The insertOne operation is missing the session option, so it is outside the transaction

B commitTransaction must be called before startTransaction

C session.endSession() must be awaited

D Transactions are not supported on the 'test' database

💡 Hint

Think about how MongoDB knows which operations belong to the transaction.

The insertOne operation must include the session option to be part of the transaction. Without it, the operation runs outside the transaction, causing commitTransaction to fail.

❓ optimization

advanced

How to optimize MongoDB transaction usage for multiple writes?

You want to perform multiple write operations inside a MongoDB transaction efficiently. Which approach is best?

A Start a session and transaction once, perform all writes with the session option, then commit once

B Start and commit a transaction for each write operation separately

C Perform writes without a transaction to avoid overhead

D Use multiple sessions, one per write, and commit each separately

💡 Hint

Think about minimizing transaction overhead and ensuring atomicity.

Starting one transaction and performing all writes inside it with the session option minimizes overhead and ensures atomicity. Multiple transactions increase overhead and reduce atomicity.

🧠 Conceptual

expert

What happens if a MongoDB transaction exceeds the maximum allowed duration?

In MongoDB, if a transaction runs longer than the configured maximum transaction lifetime, what is the expected behavior?

A The transaction pauses until manually resumed

B The transaction commits automatically regardless of duration

C The transaction is automatically aborted by the server

D The transaction continues indefinitely without interruption

💡 Hint

Consider MongoDB's safeguards to prevent long-running transactions.

MongoDB automatically aborts transactions that exceed the maximum lifetime to avoid resource exhaustion and maintain cluster health.