Bulk write operations in MongoDB - Step-by-Step Execution

Concept Flow - Bulk write operations

Prepare bulk operations array

↓

Start bulkWrite() call

↓

Execute each operation in order

↓

InsertOne

↓

Collect results

↓

Return summary of success/failures

Bulk write operations run many insert, update, or delete commands together in one call, improving speed and efficiency.

Execution Sample

MongoDB

db.collection.bulkWrite([
  { insertOne: { document: { name: "Alice" } } },
  { updateOne: { filter: { name: "Bob" }, update: { $set: { age: 30 } }, upsert: true } },
  { deleteOne: { filter: { name: "Charlie" } } }
])

This code runs three operations in bulk: insert Alice, update Bob's age or insert if missing, and delete Charlie.

Execution Table

Step	Operation Type	Details	Action Taken	Result
1	insertOne	Insert document { name: "Alice" }	Insert Alice document	InsertedCount: 1
2	updateOne	Filter: { name: "Bob" }, Update: { $set: { age: 30 } }, Upsert: true	Bob not found, insert new document	MatchedCount: 0, UpsertedCount: 1
3	deleteOne	Filter: { name: "Charlie" }	Charlie found and deleted	DeletedCount: 1
4	End	All operations processed	Bulk write completed	Summary returned

💡 All bulk operations executed in order; bulkWrite returns combined results.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
InsertedCount	0	1	1	1	1
MatchedCount	0	0	0	0	0
UpsertedCount	0	0	1	1	1
DeletedCount	0	0	0	1	1

Key Moments - 3 Insights

Why does updateOne with upsert:true insert a new document if no match is found?

Because upsert:true means 'update or insert'. If no document matches the filter, MongoDB inserts a new document with the update applied. See execution_table row 2.

Are bulk operations executed in parallel or in order?

Bulk operations run in the order they are listed, one after another. This ensures predictable results. See concept_flow and execution_table steps.

What happens if one operation in bulkWrite fails?

By default, bulkWrite stops at the first error unless ordered:false is set. This example assumes ordered:true, so it stops on error. See concept_flow and bulkWrite docs.

Visual Quiz - 3 Questions

Look at the execution_table, what is the InsertedCount after step 2?

A 1

B 0

C 2

D None

💡 Hint

Check the InsertedCount column in variable_tracker after After 2.

At which step does the bulkWrite perform a delete operation?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the Operation Type column in execution_table.

If upsert was false in step 2, what would happen?

A A new document would be inserted

B No document would be inserted or updated if Bob not found

C Charlie would be deleted twice

D Alice would be updated

💡 Hint

Refer to key_moments about upsert behavior and execution_table step 2.

Concept Snapshot

bulkWrite([{operation1}, {operation2}, ...]) runs many write ops in one call.
Operations include insertOne, updateOne, updateMany, deleteOne, deleteMany.
Runs in order; can stop on error or continue with ordered:false.
Returns summary counts: inserted, matched, upserted, deleted.
Use upsert:true to insert if no match on update.
Improves performance by reducing round trips.

Full Transcript

Bulk write operations in MongoDB let you run many insert, update, or delete commands together in one call. This example shows inserting a document named Alice, updating Bob's age or inserting if Bob doesn't exist, and deleting Charlie. Each operation runs in order. The updateOne with upsert:true inserts Bob if not found. The bulkWrite returns counts of inserted, matched, upserted, and deleted documents. This method is faster than running each operation separately because it reduces communication overhead with the database.

Practice

1. What is the main advantage of using bulkWrite() in MongoDB?

easy

A. It allows multiple write operations in a single request, improving performance.

B. It automatically backs up the database before each write.

C. It only works with read operations.

D. It requires separate calls for each write operation.

Solution

1. Step 1: Understand what bulkWrite() does

   bulkWrite() lets you send many write commands (insert, update, delete) in one call.

2. Step 2: Identify the benefit

   Sending many operations at once reduces network overhead and speeds up database changes.

3. Final Answer:

   It allows multiple write operations in a single request, improving performance. -> Option A

4. Quick Check:

   Bulk write = multiple writes in one call [OK]

Hint: Bulk write = many writes at once for speed [OK]

Common Mistakes:

• Thinking bulkWrite only reads data
• Believing it backs up data automatically
• Assuming it requires separate calls per operation

2. Which of the following is the correct syntax to perform a bulk write with an insert and an update in MongoDB?

easy

A. db.collection.bulkWrite([{ insertOne: { document: { name: 'Alice' } } }, { updateOne: { filter: { name: 'Bob' }, update: { $set: { age: 30 } } } }])

B. db.collection.bulkWrite(insertOne: { document: { name: 'Alice' } }, updateOne: { filter: { name: 'Bob' }, update: { $set: { age: 30 } } })

C. db.collection.bulkWrite([{ insert: { name: 'Alice' } }, { update: { name: 'Bob', age: 30 } }])

D. db.collection.bulkWrite([{ insertOne: { name: 'Alice' } }, { updateOne: { name: 'Bob', age: 30 } }])

Solution

1. Step 1: Check the bulkWrite syntax

   bulkWrite expects an array of operation objects like { insertOne: { document: {...} } } or { updateOne: { filter: {...}, update: {...} } }.

2. Step 2: Match options to syntax

   db.collection.bulkWrite([{ insertOne: { document: { name: 'Alice' } } }, { updateOne: { filter: { name: 'Bob' }, update: { $set: { age: 30 } } } }]) correctly uses insertOne and updateOne with proper nested objects. Others miss brackets or use wrong keys.

3. Final Answer:

   db.collection.bulkWrite([{ insertOne: { document: { name: 'Alice' } } }, { updateOne: { filter: { name: 'Bob' }, update: { $set: { age: 30 } } } }]) -> Option A

4. Quick Check:

   Correct bulkWrite syntax = db.collection.bulkWrite([{ insertOne: { document: { name: 'Alice' } } }, { updateOne: { filter: { name: 'Bob' }, update: { $set: { age: 30 } } } }]) [OK]

Hint: bulkWrite needs array of operation objects [OK]

Common Mistakes:

• Omitting the array brackets []
• Using wrong keys like 'insert' instead of 'insertOne'
• Not nesting filter and update properly

3. Given the following bulkWrite operation, what will be the result in the collection?

db.users.bulkWrite([
  { insertOne: { document: { _id: 1, name: 'John' } } },
  { updateOne: { filter: { _id: 1 }, update: { $set: { age: 25 } } } },
  { deleteOne: { filter: { name: 'John' } } }
])

medium

A. The collection will have one document: { _id: 1, name: 'John', age: 25 }

B. The operation will fail due to conflicting commands.

C. The collection will be empty after the operations.

D. The collection will have one document: { _id: 1, name: 'John' } without age.

Solution

1. Step 1: Analyze each bulkWrite operation in order

   First, insert { _id: 1, name: 'John' }. Second, update that document to add age: 25. Third, delete the document where name is 'John'.

2. Step 2: Determine final collection state

   After deletion, the document is removed, so the collection is empty.

3. Final Answer:

   The collection will be empty after the operations. -> Option C

4. Quick Check:

   Insert + update + delete = empty collection [OK]

Hint: Last delete removes the document, leaving collection empty [OK]

Common Mistakes:

• Assuming update adds a new document
• Ignoring the delete operation
• Thinking operations run independently

4. Identify the error in this bulkWrite operation:

db.products.bulkWrite([
  { insertOne: { document: { _id: 101, name: 'Pen', price: 10 } } },
  { updateOne: { filter: { _id: 101 }, update: { name: 'Pencil' } } }
])

medium

A. The filter in updateOne is incorrect.

B. The insertOne operation is missing the document key.

C. bulkWrite cannot mix insertOne and updateOne operations.

D. The update document is missing the $set operator.

Solution

1. Step 1: Review the updateOne operation

   The update document must use an update operator like $set to modify fields.

2. Step 2: Identify the missing operator

   Here, { name: 'Pencil' } is used directly, which replaces the entire document (losing the price field). It should be { $set: { name: 'Pencil' } }.

3. Final Answer:

   The update document is missing the $set operator. -> Option D

4. Quick Check:

   Update needs $set for field changes [OK]

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

Common Mistakes:

• Forgetting $set in updateOne
• Thinking insertOne needs $set
• Believing bulkWrite can't mix operations

5. You want to update multiple documents in a collection using bulkWrite(). You have these operations:

• Update user with _id 1 to set age to 30
• Update user with _id 2 to set age to 25
• Insert a new user with _id 3 and name 'Anna'

Which bulkWrite array correctly performs all these changes in one call?

hard

A. [
{ updateMany: { filter: { _id: { $in: [1, 2] } }, update: { $set: { age: 30 } } } },
{ insertOne: { document: { _id: 3, name: 'Anna' } } }
]

B. [
{ updateOne: { filter: { _id: 1 }, update: { $set: { age: 30 } } } },
{ updateOne: { filter: { _id: 2 }, update: { $set: { age: 25 } } } },
{ insertOne: { document: { _id: 3, name: 'Anna' } } }
]

C. [
{ updateOne: { filter: { _id: 1 }, update: { age: 30 } } },
{ updateOne: { filter: { _id: 2 }, update: { age: 25 } } },
{ insertOne: { document: { _id: 3, name: 'Anna' } } }
]

D. [
{ updateOne: { filter: { _id: 1 }, update: { $set: { age: 30 } } } },
{ updateOne: { filter: { _id: 2 }, update: { $set: { age: 25 } } } },
{ insertOne: { document: { name: 'Anna' } } }
]

Solution

1. Step 1: Check each updateOne operation

   Both updates correctly use updateOne with $set to change age for _id 1 and 2.

2. Step 2: Verify insertOne operation

   [ { updateOne: { filter: { _id: 1 }, update: { $set: { age: 30 } } } }, { updateOne: { filter: { _id: 2 }, update: { $set: { age: 25 } } } }, { insertOne: { document: { _id: 3, name: 'Anna' } } } ] inserts a new document with _id 3 and name 'Anna', which matches the requirement.

3. Step 3: Compare with other options

   [ { updateMany: { filter: { _id: { $in: [1, 2] } }, update: { $set: { age: 30 } } } }, { insertOne: { document: { _id: 3, name: 'Anna' } } } ] uses updateMany incorrectly (age 30 for both, but second should be 25). [ { updateOne: { filter: { _id: 1 }, update: { age: 30 } } }, { updateOne: { filter: { _id: 2 }, update: { age: 25 } } }, { insertOne: { document: { _id: 3, name: 'Anna' } } } ] misses $set. [ { updateOne: { filter: { _id: 1 }, update: { $set: { age: 30 } } } }, { updateOne: { filter: { _id: 2 }, update: { $set: { age: 25 } } } }, { insertOne: { document: { name: 'Anna' } } } ] misses _id in insert.

4. Final Answer:

   [ { updateOne: { filter: { _id: 1 }, update: { $set: { age: 30 } } } }, { updateOne: { filter: { _id: 2 }, update: { $set: { age: 25 } } } }, { insertOne: { document: { _id: 3, name: 'Anna' } } } ] -> Option B

5. Quick Check:

   Use updateOne with $set and insertOne with full document [OK]

Hint: Use updateOne with $set and insertOne with full document [OK]

Common Mistakes:

• Using update without $set
• Missing _id in insert document
• Using updateMany when individual updates differ