Transactions vs atomic document writes in MongoDB - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding atomic document writes in MongoDB

Which statement best describes atomic document writes in MongoDB?

A Atomic writes allow partial updates to a document without rollback on failure.

B Atomic writes ensure that updates within a single document are completed fully or not at all.

C Atomic writes guarantee that updates to multiple documents happen all at once or not at all.

D Atomic writes are only supported when using multi-document transactions.

💡 Hint

Think about the scope of atomicity in MongoDB without transactions.

In MongoDB, atomicity is guaranteed only at the level of a single document. Updates to multiple documents require transactions.

❓ query_result

intermediate

Result of a multi-document update without transactions

Given two documents in a collection, what happens if you update both without using a transaction and the second update fails?

MongoDB

db.collection.updateOne({_id: 1}, {$set: {status: 'processed'}})
db.collection.updateOne({_id: 2}, {$set: {status: 'processed'}}) // fails due to validation

A The first document is updated, the second update fails, so only the first document changes.

B Neither document is updated because MongoDB rolls back all changes on failure.

C Both documents remain unchanged because updates are atomic across multiple documents.

D Both documents are updated partially with some fields changed.

💡 Hint

Consider MongoDB's behavior without transactions for multiple document updates.

Without transactions, each update is independent. If the second update fails, the first remains changed.

📝 Syntax

advanced

Correct syntax for starting a transaction in MongoDB

Which code snippet correctly starts a multi-document transaction in MongoDB using the Node.js driver?

MongoDB

const session = client.startSession();
session.startTransaction();
// perform operations
await session.commitTransaction();
session.endSession();

A

const session = client.startSession();
session.startTransaction();
// operations
await session.commitTransaction();
session.endSession();

B

const session = client.startSession();
session.begin();
// operations
await session.commit();
session.end();

C

const session = client.startSession();
session.transactionStart();
// operations
await session.commitTransaction();
session.endSession();

D

const session = client.startSession();
session.beginTransaction();
// operations
await session.commitTransaction();
session.endSession();

💡 Hint

Check the official MongoDB Node.js driver API for transaction methods.

The correct method to start a transaction is startTransaction(). Other methods do not exist or cause errors.

❓ optimization

advanced

Optimizing performance when using transactions

Which practice helps optimize performance when using multi-document transactions in MongoDB?

A Include as many operations as possible in one transaction to reduce overhead.

B Use transactions only for single-document updates to improve speed.

C Keep transactions short and limit the number of operations inside them.

D Avoid using indexes inside transactions to speed up writes.

💡 Hint

Think about how long transactions hold locks and resources.

Short transactions reduce lock contention and resource usage, improving performance.

🔧 Debug

expert

Identifying the cause of a transaction abort error

You run a multi-document transaction in MongoDB but get an error: TransientTransactionError. What is the most likely cause?

A MongoDB does not support multi-document transactions on replica sets.

B The transaction included an update to a single document, which is not allowed.

C The transaction was too short and committed before any operations ran.

D A network error or primary replica failover caused the transaction to abort and require retry.

💡 Hint

Consider transient errors and retry logic in distributed systems.

TransientTransactionError usually means a temporary issue like failover or network glitch requiring retry.

Practice

1. Which statement best describes atomic document writes in MongoDB?

easy

A. They require manual rollback on failure.

B. They group multiple documents to update together.

C. They allow partial updates on multiple documents.

D. They update a single document completely or not at all.

Solution

1. Step 1: Understand atomic writes scope

   Atomic writes in MongoDB apply only to single documents, ensuring full update or no update.

2. Step 2: Compare with multi-document operations

   Multi-document updates require transactions, not atomic writes.

3. Final Answer:

   They update a single document completely or not at all. -> Option D

4. Quick Check:

   Atomic writes = single document update [OK]

Hint: Atomic writes affect one document fully or not at all [OK]

Common Mistakes:

• Thinking atomic writes cover multiple documents
• Confusing atomic writes with transactions
• Assuming partial updates are atomic

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

easy

A. session.startTransaction()

B. db.startTransaction()

C. transaction.begin()

D. start.transaction()

Solution

1. Step 1: Recall MongoDB transaction syntax

   Transactions start on a session object using startTransaction() method.

2. Step 2: Verify options

   Only session.startTransaction() matches the correct syntax.

3. Final Answer:

   session.startTransaction() -> Option A

4. Quick Check:

   Start transaction = session.startTransaction() [OK]

Hint: Use session.startTransaction() to begin transactions [OK]

Common Mistakes:

• Using db.startTransaction() which is invalid
• Confusing method names like transaction.begin()
• Incorrect method call syntax

3. Given the following code snippet, what will be the result if one update fails inside the transaction?

const session = client.startSession();
session.startTransaction();
try {
  await collection.updateOne({ _id: 1 }, { $set: { value: 10 } }, { session });
  await collection.updateOne({ _id: 2 }, { $set: { value: 20 } }, { session });
  await session.commitTransaction();
} catch (e) {
  await session.abortTransaction();
}

medium

A. Both updates are applied or none if any fails.

B. Only the first update is applied if the second fails.

C. Both updates are applied regardless of errors.

D. Updates are applied partially without rollback.

Solution

1. Step 1: Understand transaction behavior

   Transactions ensure all operations succeed or all fail together.

2. Step 2: Analyze code flow

   If any update fails, catch block aborts transaction, rolling back changes.

3. Final Answer:

   Both updates are applied or none if any fails. -> Option A

4. Quick Check:

   Transaction = all or nothing [OK]

Hint: Transactions commit all or rollback all changes [OK]

Common Mistakes:

• Assuming partial updates apply on failure
• Ignoring abortTransaction() effect
• Thinking updates apply independently

4. Identify the error in this MongoDB transaction code snippet:

const session = client.startSession();
session.startTransaction();
await collection.updateOne({ _id: 1 }, { $set: { value: 10 } });
await session.commitTransaction();
session.endSession();

medium

A. updateOne cannot be used inside transactions.

B. Missing session option in updateOne call.

C. startTransaction() must be called after updateOne.

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

Solution

1. Step 1: Check transaction usage in updateOne

   Operations inside a transaction must include the session option to link them.

2. Step 2: Verify code calls

   updateOne lacks { session } option, so it runs outside transaction.

3. Final Answer:

   Missing session option in updateOne call. -> Option B

4. Quick Check:

   Include session in operations inside transactions [OK]

Hint: Always pass { session } to operations inside transactions [OK]

Common Mistakes:

• Forgetting to pass session option in operations
• Calling endSession before commitTransaction
• Misordering startTransaction call

5. You need to update a user's profile document and also add a log entry in a separate collection. Which approach is best to ensure both updates succeed or fail together?

hard

A. Perform two separate atomic document writes without transactions.

B. Update the profile document atomically and ignore the log entry.

C. Use a transaction to update both collections atomically.

D. Update the log entry first, then the profile document without transactions.

Solution

1. Step 1: Identify multi-document update requirement

   Updating two collections means multiple documents involved.

2. Step 2: Choose appropriate method

   Transactions ensure both updates succeed or fail together, preserving consistency.

3. Final Answer:

   Use a transaction to update both collections atomically. -> Option C

4. Quick Check:

   Multi-document update = use transactions [OK]

Hint: Use transactions for multi-document atomic updates [OK]

Common Mistakes:

• Using atomic writes for multiple collections
• Ignoring failure possibility in one update
• Assuming separate writes are automatically atomic