Single document atomicity in MongoDB - Step-by-Step Execution

Concept Flow - Single document atomicity

Start Transaction

↓

Modify Single Document

↓

Apply All Changes Atomically

↓

Commit Changes

↓

End Transaction

When you update a single document in MongoDB, all changes happen together or not at all, ensuring data stays consistent.

Execution Sample

MongoDB

db.users.updateOne(
  { _id: 1 },
  { $set: { name: "Alice", age: 30 } }
)

This updates the user with _id 1, changing name and age together in one atomic operation.

Execution Table

Step	Action	Document State Before	Change Applied	Document State After
1	Locate document with _id=1	{ _id: 1, name: "Bob", age: 25 }	None	{ _id: 1, name: "Bob", age: 25 }
2	Apply $set changes atomically	{ _id: 1, name: "Bob", age: 25 }	{ $set: { name: "Alice", age: 30 } }	{ _id: 1, name: "Alice", age: 30 }
3	Commit changes	{ _id: 1, name: "Alice", age: 30 }	None	{ _id: 1, name: "Alice", age: 30 }
4	End operation	{ _id: 1, name: "Alice", age: 30 }	None	{ _id: 1, name: "Alice", age: 30 }

💡 All changes applied atomically to the single document; operation completes successfully.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
document	{ _id: 1, name: "Bob", age: 25 }	{ _id: 1, name: "Bob", age: 25 }	{ _id: 1, name: "Alice", age: 30 }	{ _id: 1, name: "Alice", age: 30 }	{ _id: 1, name: "Alice", age: 30 }

Key Moments - 2 Insights

Why do both fields 'name' and 'age' change together and not separately?

Because MongoDB applies all updates to a single document atomically, as shown in execution_table step 2, so either all changes happen or none do.

What happens if the update fails halfway through?

The entire update is rolled back, so the document stays unchanged, ensuring atomicity as implied by the exit_note.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what changes are applied to the document?

A Only the 'name' field is changed

B Only the 'age' field is changed

C Both 'name' and 'age' fields are changed together

D No changes are applied

💡 Hint

Check the 'Change Applied' column at step 2 in execution_table

At which step does the document state first reflect the updated values?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Document State After' column in execution_table

If the update operation failed after applying changes but before commit, what would the final document state be?

A Original document unchanged

B Partially updated document

C Document deleted

D Document with only 'name' updated

💡 Hint

Refer to the atomicity principle explained in key_moments and exit_note

Concept Snapshot

Single document atomicity in MongoDB means all changes to one document happen together or not at all.
Use update operations like updateOne to modify fields.
If any part fails, no changes are saved.
This keeps data consistent and reliable.

Full Transcript

In MongoDB, when you update a single document, all changes are applied atomically. This means either all the changes happen together or none happen at all. For example, if you update the name and age fields of a user document, both fields change at the same time. The execution flow starts by locating the document, then applying all changes together, committing them, and ending the operation. If the update fails at any point, the document remains unchanged. This ensures data consistency and reliability.

Practice

1. What does single document atomicity mean in MongoDB?

easy

A. All changes to a single document happen completely or not at all

B. Multiple documents are updated at the same time atomically

C. Only one field in a document can be updated at a time

D. Documents are locked during any update operation

Solution

1. Step 1: Understand atomicity in MongoDB context

   MongoDB guarantees that updates to a single document are atomic, meaning all changes in that update happen fully or not at all.

2. Step 2: Compare options with this definition

   All changes to a single document happen completely or not at all correctly states this. Options A, B, and D describe behaviors that are not true for single document atomicity.

3. Final Answer:

   All changes to a single document happen completely or not at all -> Option A

4. Quick Check:

   Single document atomicity = All-or-nothing update [OK]

Hint: Atomic means all or nothing for one document update [OK]

Common Mistakes:

• Thinking atomicity applies to multiple documents
• Believing only one field updates atomically
• Assuming document locking happens automatically

2. Which of the following is the correct syntax to update a single document atomically in MongoDB?

easy

A. db.collection.update({ _id: 1 }, { name: 'Alice' })

B. db.collection.updateMany({ _id: 1 }, { $set: { name: 'Alice' } })

C. db.collection.modifyOne({ _id: 1 }, { $set: { name: 'Alice' } })

D. db.collection.updateOne({ _id: 1 }, { $set: { name: 'Alice' } })

Solution

1. Step 1: Identify the correct update method for one document

   The method updateOne updates a single document atomically. It uses a filter and an update operator like $set.

2. Step 2: Check each option's syntax

   db.collection.updateOne({ _id: 1 }, { $set: { name: 'Alice' } }) uses updateOne with $set, which is correct. db.collection.update({ _id: 1 }, { name: 'Alice' }) uses deprecated update without update operator. db.collection.modifyOne({ _id: 1 }, { $set: { name: 'Alice' } }) uses a non-existent method modifyOne. db.collection.updateMany({ _id: 1 }, { $set: { name: 'Alice' } }) updates many documents, not one.

3. Final Answer:

   db.collection.updateOne({ _id: 1 }, { $set: { name: 'Alice' } }) -> Option D

4. Quick Check:

   Use updateOne with $set for atomic single document update [OK]

Hint: Use updateOne with $set to update one document atomically [OK]

Common Mistakes:

• Using update without $set operator
• Using updateMany when only one document should update
• Using non-existent methods like modifyOne

3. Given the document { _id: 1, count: 5 }, what will be the document after this atomic update?

db.collection.updateOne({ _id: 1 }, { $inc: { count: 3 }, $set: { status: 'active' } })

medium

A. { _id: 1, count: 3, status: 'active' }

B. { _id: 1, count: 8, status: 'active' }

C. { _id: 1, count: 5 }

D. Update fails with error

Solution

1. Step 1: Understand the update operators used

   The $inc operator increases the count field by 3. The $set operator adds or updates the status field to 'active'.

2. Step 2: Calculate the new document values

   Original count is 5, incremented by 3 gives 8. The status field is set to 'active'.

3. Final Answer:

   { _id: 1, count: 8, status: 'active' } -> Option B

4. Quick Check:

   $inc adds 3, $set adds status [OK]

Hint: Combine $inc and $set to update fields atomically [OK]

Common Mistakes:

• Thinking $inc replaces the field instead of adding
• Ignoring $set operator effect
• Assuming update fails without errors

4. You wrote this update but it does not work as expected:

db.collection.updateOne({ _id: 2 }, { count: 10, status: 'done' })

What is the problem?

medium

A. The collection name is invalid

B. The filter {_id: 2} is incorrect syntax

C. Missing update operator like $set causes the update to replace the entire document

D. updateOne cannot update multiple fields at once

Solution

1. Step 1: Check the update document structure

   The update document must use update operators like $set to specify fields to change. Here, the update document lacks any operator.

2. Step 2: Understand MongoDB update syntax rules

   Without an operator, MongoDB treats the update document as a replacement document, overwriting the entire document. This causes unexpected behavior if other fields exist.

3. Final Answer:

   Missing update operator like $set causes the update to replace the entire document -> Option C

4. Quick Check:

   Always use $set or other operators in update document [OK]

Hint: Always use $set or operators in update documents [OK]

Common Mistakes:

• Forgetting $set causes full document replacement
• Assuming updateOne updates fields without operators
• Misunderstanding filter syntax

5. You want to update a user's profile atomically to change their email and increment their login count. Which update operation ensures atomicity and correctness?

db.users.updateOne(
  { _id: 123 },
  { $set: { email: '[e-mail]' }, $inc: { logins: 1 } }
)

Why is this update atomic and what would happen if you tried to update email and logins in two separate updateOne calls?

hard

A. This update is atomic because both changes happen together; separate calls risk partial updates

B. This update is not atomic; MongoDB cannot update two fields at once

C. Separate updateOne calls are better for performance and atomicity

D. Atomicity only applies to single field updates, so this is invalid

Solution

1. Step 1: Understand atomicity of single document updates

   MongoDB guarantees that all changes in a single updateOne call on one document happen fully or not at all, ensuring atomicity.

2. Step 2: Compare single update vs multiple updates

   Using one updateOne with both $set and $inc ensures both fields change together. Using two separate updateOne calls risks one succeeding and the other failing, causing inconsistent data.

3. Final Answer:

   This update is atomic because both changes happen together; separate calls risk partial updates -> Option A

4. Quick Check:

   Single updateOne call = atomic multi-field update [OK]

Hint: Combine changes in one updateOne call for atomicity [OK]

Common Mistakes:

• Thinking atomicity applies across multiple update calls
• Believing MongoDB can't update multiple fields atomically
• Assuming separate updates are safer