Multi-document transactions in MongoDB - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a multi-document transaction in MongoDB?

A multi-document transaction in MongoDB is a way to group multiple read and write operations across multiple documents and collections into a single atomic operation. This means all operations succeed or fail together.

beginner

Why are multi-document transactions useful?

They ensure data consistency when changes affect multiple documents or collections. If one operation fails, all changes are rolled back, preventing partial updates.

intermediate

How do you start a multi-document transaction in MongoDB?

You start a session and then call the startTransaction() method on that session before performing operations.

intermediate

What happens if a transaction is not committed in MongoDB?

If a transaction is not committed, it will be aborted and all changes made during the transaction will be discarded.

advanced

Can multi-document transactions impact performance in MongoDB?

Yes, because transactions require extra overhead to maintain atomicity and consistency, they can slow down operations compared to single-document writes.

What is the first step to use a multi-document transaction in MongoDB?

A Run a query

B Insert a document

C Create an index

D Start a session

You must start a session before starting a transaction.

Which method commits a transaction in MongoDB?

A commitTransaction()

B startTransaction()

C abortTransaction()

D endSession()

commitTransaction() finalizes and saves all changes made in the transaction.

If one operation in a multi-document transaction fails, what happens?

A Only the failed operation is retried

B The transaction continues ignoring the failure

C All operations are rolled back

D The database shuts down

MongoDB rolls back all operations to keep data consistent.

Multi-document transactions in MongoDB can span how many collections?

A One collection only

B Multiple collections

C Only system collections

D None, transactions are not supported

Transactions can include operations on multiple collections.

Which MongoDB feature is required to use multi-document transactions?

A Replica set or sharded cluster

B Standalone server

C Only local database

D No special feature needed

Transactions require a replica set or sharded cluster environment.

Explain how multi-document transactions work in MongoDB and why they are important.

Think about grouping operations so they all succeed or fail together.

Describe the steps to perform a multi-document transaction in MongoDB.

Consider the order of commands needed to ensure atomicity.

Practice

1. What is the main purpose of using multi-document transactions in MongoDB?

easy

A. To create indexes automatically

B. To speed up single document queries

C. To ensure multiple document changes succeed or fail together

D. To backup the database

Solution

1. Step 1: Understand transaction purpose

   Transactions group multiple operations so they either all succeed or all fail, ensuring data consistency.

2. Step 2: Compare options

   Only To ensure multiple document changes succeed or fail together describes this behavior. Other options describe unrelated features.

3. Final Answer:

   To ensure multiple document changes succeed or fail together -> Option C

4. Quick Check:

   Transaction purpose = group changes atomically [OK]

Hint: Transactions group multiple changes to keep data consistent [OK]

Common Mistakes:

• Confusing transactions with indexing
• Thinking transactions speed up single queries
• Assuming transactions create backups

2. Which of the following is the correct way to start a transaction in a MongoDB session using the Node.js driver?

easy

A. db.transactionStart()

B. session.startTransaction()

C. session.begin()

D. start.sessionTransaction()

Solution

1. Step 1: Recall MongoDB transaction syntax

   The correct method to start a transaction on a session is startTransaction().

2. Step 2: Eliminate incorrect options

   Options A, B, and D are not valid MongoDB session methods.

3. Final Answer:

   session.startTransaction() -> Option B

4. Quick Check:

   Start transaction method = startTransaction() [OK]

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

Common Mistakes:

• Using incorrect method names like begin()
• Calling transaction methods on db instead of session
• Mixing method order or syntax

3. Consider this MongoDB transaction code snippet in Node.js:

const session = client.startSession();
session.startTransaction();
await collection1.insertOne({item: 'apple'}, {session});
await collection2.updateOne({item: 'banana'}, {$inc: {qty: 1}}, {session});
await session.commitTransaction();
session.endSession();
console.log('Transaction complete');

What will be printed if both operations succeed?

medium

A. Transaction complete

B. Transaction aborted

C. Error: session not started

D. No output

Solution

1. Step 1: Analyze transaction flow

   The code starts a session, begins a transaction, performs two operations, commits the transaction, ends the session, then logs a message.

2. Step 2: Determine output on success

   If both operations succeed and commitTransaction() completes without error, the console.log will print 'Transaction complete'.

3. Final Answer:

   Transaction complete -> Option A

4. Quick Check:

   Successful commit logs 'Transaction complete' [OK]

Hint: If commitTransaction succeeds, console logs 'Transaction complete' [OK]

Common Mistakes:

• Assuming commitTransaction logs automatically
• Confusing session start errors with commit success
• Ignoring async/await behavior

4. You wrote this MongoDB transaction code but it throws an error:

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

What is the error and how to fix it?

medium

A. insertOne does not accept session option

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

C. session.startSession() should be awaited

D. Missing parentheses on startTransaction; use session.startTransaction()

Solution

1. Step 1: Identify the syntax error

   The code calls session.startTransaction without parentheses, so the function is not executed.

2. Step 2: Correct the method call

   Add parentheses to call the function: session.startTransaction().

3. Final Answer:

   Missing parentheses on startTransaction; use session.startTransaction() -> Option D

4. Quick Check:

   Method calls need parentheses () [OK]

Hint: Always add () to call methods like startTransaction() [OK]

Common Mistakes:

• Forgetting parentheses on method calls
• Calling endSession before commitTransaction
• Thinking startSession is async and needs await

5. You want to update two collections atomically: deduct 10 from accounts.balance and add 10 to transactions.amount. Which transaction code snippet correctly ensures both updates succeed or fail together?

hard

A. const session = client.startSession();
session.startTransaction();
await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session});
await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session});
await session.commitTransaction();
session.endSession();

B. await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}});
await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}});

C. const session = client.startSession();
await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session});
await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session});
session.commitTransaction();
session.endSession();

D. const session = client.startSession();
session.startTransaction();
accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session});
transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session});
session.commitTransaction();
session.endSession();

Solution

1. Step 1: Check transaction start and commit

   const session = client.startSession(); session.startTransaction(); await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session}); await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session}); await session.commitTransaction(); session.endSession(); correctly calls startTransaction() and commitTransaction() on the session.

2. Step 2: Verify operations use session and await

   const session = client.startSession(); session.startTransaction(); await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session}); await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session}); await session.commitTransaction(); session.endSession(); uses await on both update operations and passes the session option, ensuring atomicity.

3. Step 3: Identify errors in other options

   await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}); await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}); lacks transaction usage. const session = client.startSession(); await accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session}); await transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session}); session.commitTransaction(); session.endSession(); misses startTransaction(). const session = client.startSession(); session.startTransaction(); accounts.updateOne({user: 'A'}, {$inc: {balance: -10}}, {session}); transactions.updateOne({user: 'A'}, {$inc: {amount: 10}}, {session}); session.commitTransaction(); session.endSession(); misses await on operations.

4. Final Answer:

   Option A code snippet -> Option A

5. Quick Check:

   Start, await ops with session, commit = correct transaction [OK]

Hint: Start transaction, await ops with session, then commit [OK]

Common Mistakes:

• Not awaiting async operations inside transaction
• Forgetting to start the transaction
• Running operations outside session context