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.

Practice

1. What is a key reason to use transactions in MongoDB?

easy

A. To keep data changes safe and consistent

B. To speed up query execution

C. To reduce disk space usage

D. To avoid indexing

Solution

1. Step 1: Understand the purpose of transactions

   Transactions ensure that multiple related data changes happen together or not at all, keeping data consistent.

2. Step 2: Identify the correct purpose

   Speeding up queries, reducing disk space, or avoiding indexing are not the main reasons for transactions.

3. Final Answer:

   To keep data changes safe and consistent -> Option A

4. Quick Check:

   Transactions = Data safety and consistency [OK]

Hint: Transactions ensure data safety, not speed [OK]

Common Mistakes:

• Thinking transactions speed up queries
• Confusing transactions with indexing
• Believing transactions reduce disk space

2. Which of the following is the correct way to start a transaction in MongoDB using the shell?

easy

A. transaction.begin()

B. db.startTransaction()

C. startTransaction()

D. session.startTransaction()

Solution

1. Step 1: Recall MongoDB transaction syntax

   Transactions are started on a session object using session.startTransaction().

2. Step 2: Check other options

   db.startTransaction() and startTransaction() are invalid commands. transaction.begin() is not a MongoDB method.

3. Final Answer:

   session.startTransaction() -> Option D

4. Quick Check:

   Start transaction = session.startTransaction() [OK]

Hint: Transactions start on session objects with startTransaction() [OK]

Common Mistakes:

• Trying to start transaction directly on db object
• Using incomplete or wrong method names
• Confusing transaction start with commit or abort

3. Consider this MongoDB transaction code snippet:

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

What is the expected result of this code?

medium

A. The document is inserted but not in a transaction

B. The document {name: 'Alice'} is inserted safely in a transaction

C. The code throws a syntax error

D. The transaction is aborted automatically

Solution

1. Step 1: Analyze transaction steps

   The code starts a session, begins a transaction, inserts a document with the session, commits the transaction, and ends the session.

2. Step 2: Understand transaction effect

   Because the insert is done inside the transaction and committed, the document is safely inserted as part of the transaction.

3. Final Answer:

   The document {name: 'Alice'} is inserted safely in a transaction -> Option B

4. Quick Check:

   Transaction insert + commit = safe insert [OK]

Hint: Insert inside transaction + commit = safe insert [OK]

Common Mistakes:

• Ignoring the session option in insertOne
• Assuming transaction auto-aborts without error
• Confusing syntax errors with runtime behavior

4. You wrote this code but the transaction does not commit:

const session = client.startSession();
session.startTransaction();
await collection.insertOne({item: 'book'});
await session.commitTransaction();
session.endSession();

What is the main issue causing the transaction to fail?

medium

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

B. commitTransaction() must be called before startTransaction()

C. The insertOne operation is missing the session option

D. Transactions cannot include insertOne operations

Solution

1. Step 1: Check transaction usage in code

   The insertOne call does not include the session option, so it runs outside the transaction.

2. Step 2: Understand transaction requirements

   All operations inside a transaction must specify the session to be part of it. Without it, commitTransaction has no effect on that operation.

3. Final Answer:

   The insertOne operation is missing the session option -> Option C

4. Quick Check:

   Missing session in operation = transaction fails [OK]

Hint: Include session option in all operations inside transactions [OK]

Common Mistakes:

• Calling commitTransaction before startTransaction
• Ending session before committing
• Thinking insertOne can't be in transactions

5. Which practice helps improve transaction performance in MongoDB when working with many documents?

hard

A. Keep transactions short and avoid long-running operations

B. Use transactions for every single write operation

C. Avoid using indexes inside transactions

D. Run multiple transactions in parallel on the same documents

Solution

1. Step 1: Understand transaction performance impact

   Long transactions hold locks and resources longer, slowing performance and increasing conflicts.

2. Step 2: Identify best practice

   Keeping transactions short reduces lock time and improves throughput. Using transactions for every write or running parallel conflicting transactions harms performance. Indexes improve query speed and are not avoided.

3. Final Answer:

   Keep transactions short and avoid long-running operations -> Option A

4. Quick Check:

   Short transactions = better performance [OK]

Hint: Keep transactions short to boost speed and reduce conflicts [OK]

Common Mistakes:

• Using transactions for every write unnecessarily
• Avoiding indexes inside transactions
• Running conflicting transactions in parallel