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.