Commit and abort behavior in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output after a successful commit in a MongoDB transaction?

Consider a MongoDB transaction that inserts a document into the users collection and then commits successfully. What will be the result of querying users after the commit?

MongoDB

session.startTransaction();
db.users.insertOne({name: 'Alice'}, {session});
session.commitTransaction();
db.users.find({name: 'Alice'}).toArray();

A [{_id: ObjectId(...), name: 'Alice'}]

B null

C TransactionError

D []

💡 Hint

Think about what happens to data after a commit in a transaction.

After a successful commit, the inserted document becomes visible outside the transaction, so querying returns the new document.

❓ query_result

intermediate

What happens to data after aborting a MongoDB transaction?

A transaction inserts a document into the orders collection but then aborts. What will be the result of querying orders for that document?

MongoDB

session.startTransaction();
db.orders.insertOne({orderId: 123}, {session});
session.abortTransaction();
db.orders.find({orderId: 123}).toArray();

A TransactionAbortedError

B [{orderId: 123}]

C []

D null

💡 Hint

Consider what aborting a transaction does to the changes made inside it.

Aborting a transaction discards all changes made during it, so the inserted document is not saved.

📝 Syntax

advanced

Which option correctly starts and commits a MongoDB transaction?

Identify the option that uses correct syntax to start a session, begin a transaction, insert a document, and commit the transaction.

A

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

B

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

C

const session = client.startSession();
session.beginTransaction();
db.collection('products').insertOne({item: 'book'}, {session});
session.commit();
session.endSession();

D

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

💡 Hint

Check the correct method names and usage of session in operations.

Option B correctly uses startTransaction(), passes the session to the insert operation, commits, and ends the session.

🔧 Debug

advanced

Why does this MongoDB transaction fail to commit?

Given the code below, why does the transaction fail to commit?

MongoDB

const session = client.startSession();
session.startTransaction();
db.collection('inventory').updateOne({sku: 'abc'}, {$inc: {qty: -1}}, {session});
session.commitTransaction();
session.endSession();

A The update operation is missing the session option, so it is not part of the transaction.

B The transaction cannot update documents, only insert.

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

D endSession() must be called before commitTransaction().

💡 Hint

Think about how MongoDB knows which operations belong to the transaction.

Operations must include the session option to be part of the transaction. Without it, the update runs outside the transaction, causing commit failure.

🧠 Conceptual

expert

What is the effect of a multi-document transaction abort in MongoDB?

In a multi-document transaction that modifies several collections, what happens if the transaction aborts?

A Changes are partially saved depending on the order of operations.

B Only changes in the first collection are rolled back; others remain.

C The transaction abort causes a partial commit of changes.

D All changes made in all collections during the transaction are rolled back, leaving the database unchanged.

💡 Hint

Recall the atomicity property of transactions.

MongoDB transactions are atomic; aborting rolls back all changes made during the transaction across all collections.

Practice

1. What happens when you commit a transaction in MongoDB?

easy

A. All changes made during the transaction are saved permanently.

B. All changes made during the transaction are discarded.

C. The transaction is paused and can be resumed later.

D. Only some changes are saved, others are lost.

Solution

1. Step 1: Understand commit behavior

   Committing a transaction means saving all changes made during that transaction permanently to the database.

2. Step 2: Compare with abort

   Unlike abort, which cancels changes, commit finalizes them.

3. Final Answer:

   All changes made during the transaction are saved permanently. -> Option A

4. Quick Check:

   Commit = Save changes [OK]

Hint: Commit means save all changes made in the transaction [OK]

Common Mistakes:

• Confusing commit with abort
• Thinking commit only saves some changes
• Believing commit pauses the transaction

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

easy

A. transaction.abort()

B. session.abortTransaction()

C. db.abort()

D. session.commit()

Solution

1. Step 1: Recall MongoDB transaction abort syntax

   The correct method to abort a transaction is session.abortTransaction().

2. Step 2: Eliminate incorrect options

   session.commit() is invalid, db.abort() and transaction.abort() are not valid MongoDB shell commands.

3. Final Answer:

   session.abortTransaction() -> Option B

4. Quick Check:

   Abort transaction = session.abortTransaction() [OK]

Hint: Abort transaction uses session.abortTransaction() method [OK]

Common Mistakes:

• Using commit() instead of abortTransaction()
• Trying to abort with db.abort() which doesn't exist
• Confusing transaction object with session

3. Consider this MongoDB transaction code snippet:

const session = client.startSession();
session.startTransaction();
await collection.insertOne({name: 'Alice'}, {session});
await session.abortTransaction();
const count = await collection.countDocuments({name: 'Alice'});
console.log(count);

What will be printed?

medium

A. 0

B. 1

C. undefined

D. Error

Solution

1. Step 1: Analyze transaction operations

   The document insertion happens inside a transaction that is aborted immediately after.

2. Step 2: Understand abort effect on data

   Aborting the transaction cancels the insert, so the document is not saved.

3. Final Answer:

   0 -> Option A

4. Quick Check:

   Abort cancels insert, count = 0 [OK]

Hint: Aborted inserts do not persist, count remains zero [OK]

Common Mistakes:

• Assuming insert stays after abort
• Expecting count to be 1
• Thinking abort throws error

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

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

What is the likely cause of the error?

medium

A. insertOne() is missing session option

B. startTransaction() is called twice

C. Missing await before commitTransaction()

D. endSession() must be called before commitTransaction()

Solution

1. Step 1: Check async calls in transaction

   commitTransaction() returns a promise and must be awaited to complete properly.

2. Step 2: Identify missing await causes error

   Without await, the code may proceed before commit finishes, causing errors.

3. Final Answer:

   Missing await before commitTransaction() -> Option C

4. Quick Check:

   Async commit needs await [OK]

Hint: Always await commitTransaction() to avoid errors [OK]

Common Mistakes:

• Not awaiting commitTransaction()
• Calling startTransaction() multiple times
• Calling endSession() too early

5. You want to update two documents atomically in MongoDB. You start a transaction, update the first document, then update the second. If the second update fails, what should you do to ensure no partial changes remain?

hard

A. Manually delete the first update after failure.

B. Commit the transaction to save the first update only.

C. Ignore the failure and continue.

D. Abort the transaction to cancel all changes.

Solution

1. Step 1: Understand atomicity in transactions

   Transactions ensure all-or-nothing changes. If one update fails, the whole transaction should be canceled.

2. Step 2: Apply abort to cancel partial changes

   Aborting the transaction cancels all changes, preventing partial updates.

3. Final Answer:

   Abort the transaction to cancel all changes. -> Option D

4. Quick Check:

   Fail in transaction = abort all changes [OK]

Hint: Abort transaction to avoid partial updates on failure [OK]

Common Mistakes:

• Committing partial updates
• Trying to manually fix partial changes
• Ignoring failure and continuing