Transaction performance considerations in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Impact of Transaction Size on Performance

In MongoDB, how does increasing the size of a transaction (number of operations inside it) generally affect performance?

A Performance degrades because larger transactions hold locks longer and consume more resources.

B Performance improves because more operations are grouped together reducing overhead.

C Performance remains the same regardless of transaction size.

D Performance improves only if the transaction contains write operations.

💡 Hint

Think about how holding locks longer affects other operations.

Larger transactions hold locks for longer periods, which can block other operations and increase resource consumption, leading to degraded performance.

❓ query_result

intermediate

Transaction Duration Measurement Query

Given a MongoDB collection orders with a field status, which query snippet correctly measures the total time taken by a transaction that updates multiple documents?

MongoDB

const session = client.startSession();
const start = Date.now();
session.startTransaction();
try {
  await orders.updateMany({ status: 'pending' }, { $set: { status: 'processed' } }, { session });
  await orders.updateMany({ status: 'processed' }, { $set: { status: 'completed' } }, { session });
  await session.commitTransaction();
} catch (e) {
  await session.abortTransaction();
}
const end = Date.now();
const duration = end - start;

A The variable <code>duration</code> measures only the commitTransaction time.

B The variable <code>duration</code> holds the total transaction time in milliseconds.

C The variable <code>duration</code> will always be zero because transactions are asynchronous.

D The variable <code>duration</code> holds the time only for the first updateMany operation.

💡 Hint

Consider when start and end are recorded relative to the transaction.

The duration variable measures the elapsed time from before starting the transaction to after committing or aborting it, thus capturing the total transaction time.

📝 Syntax

advanced

Identify the Syntax Error in Transaction Usage

Which of the following MongoDB transaction code snippets contains a syntax error that prevents it from running?

MongoDB

const session = client.startSession();
session.startTransaction();
try {
  await collection.insertOne({ name: 'Alice' }, { session });
  await session.commitTransaction();
} catch (error) {
  await session.abortTransaction();
} finally {
  session.endSession();
}

A Calling <code>session.endSession()</code> inside finally block is invalid syntax.

B Missing async keyword before the function containing await calls.

C Using <code>await</code> without <code>async</code> causes a syntax error.

D The <code>startTransaction()</code> method requires a callback function.

💡 Hint

Check if await is used inside an async function.

Using await outside an async function causes a syntax error in JavaScript.

❓ optimization

advanced

Optimizing Transaction Performance by Reducing Contention

Which strategy best reduces transaction contention and improves performance in MongoDB?

A Use shorter transactions that touch fewer documents to reduce lock time.

B Increase transaction size to batch more operations together.

C Use transactions only for read operations to avoid write locks.

D Disable journaling to speed up commit times.

💡 Hint

Think about how lock duration affects other operations.

Shorter transactions that modify fewer documents hold locks for less time, reducing contention and improving overall performance.

🔧 Debug

expert

Diagnosing a Transaction Timeout Issue

A MongoDB transaction frequently aborts with a timeout error. Which of the following is the most likely cause?

A The client session was not started before the transaction.

B The transaction uses an unsupported write concern level.

C The transaction includes too many read operations causing network delays.

D The transaction holds locks for too long due to large or slow operations.

💡 Hint

Consider what causes transactions to exceed timeout limits.

Long-running transactions that hold locks too long can cause timeout errors because MongoDB aborts transactions that exceed configured time limits to avoid blocking other operations.