Batch writes in Firebase - Step-by-Step Execution

Process Flow - Batch writes

Start Batch Write

↓

Add Write Operation 1

↓

Add Write Operation 2

↓

Commit Batch

↓

All Writes Applied Atomically

↓

End

Batch writes collect multiple write operations and apply them all at once atomically.

Execution Sample

Firebase

const batch = db.batch();
const doc1 = db.collection('users').doc('user1');
batch.set(doc1, {name: 'Alice'});
const doc2 = db.collection('users').doc('user2');
batch.update(doc2, {age: 30});
await batch.commit();

This code creates a batch, adds two write operations, then commits them together.

Process Table

Step	Action	Batch State	Result
1	Create batch object	Empty batch	Batch initialized
2	Add set operation for doc1	Batch with 1 write (set user1)	Operation queued
3	Add update operation for doc2	Batch with 2 writes (set user1, update user2)	Operation queued
4	Commit batch	Batch with 2 writes	Writes applied atomically
5	Batch cleared after commit	Empty batch	Ready for new writes

💡 Batch commit applies all writes atomically, then batch resets

Status Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5
batch	undefined	1 write queued	2 writes queued	writes committed	empty batch

Key Moments - 3 Insights

Why do all writes happen at once and not one by one?

Because batch.commit() applies all queued writes atomically in one step, as shown in execution_table step 4.

What happens if one write in the batch fails?

The entire batch fails and no writes are applied, ensuring atomicity (all or nothing), as implied by the commit step in execution_table.

Can I reuse the batch object after commit?

No, after commit the batch is cleared (step 5), so you need to create a new batch for more writes.

Visual Quiz - 3 Questions

Look at the execution_table, what is the batch state after adding the second write?

A Empty batch

B Batch with 2 writes

C Batch with 1 write

D Writes committed

💡 Hint

Check execution_table row 3 under 'Batch State'

At which step does the batch apply all writes atomically?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for 'Writes applied atomically' in execution_table

If you try to add a write after commit without creating a new batch, what happens?

A You must create a new batch first

B The batch is empty so write is queued normally

C The write is queued in the old batch

D The write is automatically committed

💡 Hint

Refer to variable_tracker and key_moments about batch state after commit

Concept Snapshot

Batch writes let you queue multiple write operations.
Use db.batch() to start.
Add writes with batch.set(), batch.update(), etc.
Call batch.commit() to apply all writes atomically.
Batch resets after commit; create new batch for more writes.

Full Transcript

Batch writes in Firebase let you group multiple write operations together. You start by creating a batch object. Then you add write operations like set or update to the batch. These writes are not applied immediately but queued. When you call commit on the batch, all writes are applied at once atomically, meaning either all succeed or none do. After commit, the batch is cleared and you need a new batch object for more writes. This ensures consistency and efficiency when updating multiple documents.

Practice

1. What is the main purpose of using batch writes in Firebase?

easy

A. To group multiple data changes into a single request

B. To read data faster from the database

C. To create multiple databases at once

D. To backup data automatically

Solution

1. Step 1: Understand batch writes concept

   Batch writes allow grouping many data changes into one request to keep data consistent.

2. Step 2: Identify the main purpose

   The main purpose is to combine multiple changes to save time and ensure consistency.

3. Final Answer:

   To group multiple data changes into a single request -> Option A

4. Quick Check:

   Batch writes = group changes [OK]

Hint: Batch writes combine changes to save time and keep data consistent [OK]

Common Mistakes:

• Thinking batch writes speed up data reading
• Confusing batch writes with database creation
• Assuming batch writes automatically backup data

2. Which of the following is the correct way to start a batch write in Firebase?

easy

A. const batch = firestore.batch();

B. const batch = firestore.startBatch();

C. const batch = firestore.createBatchWrite();

D. const batch = firestore.newBatch();

Solution

1. Step 1: Recall Firebase batch write syntax

   The correct method to start a batch is firestore.batch().

2. Step 2: Compare options

   Only const batch = firestore.batch(); uses the exact Firebase API method firestore.batch().

3. Final Answer:

   const batch = firestore.batch(); -> Option A

4. Quick Check:

   Start batch with firestore.batch() [OK]

Hint: Use firestore.batch() to start batch writes [OK]

Common Mistakes:

• Using non-existent methods like startBatch or newBatch
• Confusing batch creation with other Firestore methods
• Misspelling the batch method name

3. What will happen if you run this Firebase batch write code?

const batch = firestore.batch();
const docRef1 = firestore.collection('users').doc('user1');
batch.set(docRef1, {name: 'Alice'});
const docRef2 = firestore.collection('users').doc('user2');
batch.update(docRef2, {age: 30});
await batch.commit();

medium

A. Both documents 'user1' and 'user2' will be updated or created as specified

B. Only 'user1' document will be created; 'user2' update will fail silently

C. The batch commit will fail if 'user2' document does not exist

D. The batch will commit but no changes will be made

Solution

1. Step 1: Understand batch set and update behavior

   batch.set creates or overwrites a document; batch.update requires the document to exist.

2. Step 2: Analyze the code effect

   Since 'user2' might not exist, batch.update will cause the entire batch commit to fail.

3. Final Answer:

   The batch commit will fail if 'user2' document does not exist -> Option C

4. Quick Check:

   batch.update needs existing doc = fail if missing [OK]

Hint: batch.update fails if document missing, causing batch failure [OK]

Common Mistakes:

• Assuming batch.update creates documents
• Thinking batch.commit partially applies changes
• Ignoring that batch fails on any single error

4. Identify the error in this Firebase batch write code:

const batch = firestore.batch();
const docRef = firestore.collection('items').doc('item1');
batch.update(docRef, {price: 100});
batch.set(docRef, {name: 'Book'});
await batch.commit();

medium

A. Calling batch.update before batch.set on the same document causes an error

B. batch.set cannot be used after batch.update in the same batch

C. batch.update requires a callback function

D. No error; batch.commit will succeed and apply both changes

Solution

1. Step 1: Review batch operation order rules

   Firebase batch allows multiple operations on the same doc; last write wins.

2. Step 2: Analyze the code

   batch.update then batch.set on same doc means set overwrites update fields.

3. Final Answer:

   No error; batch.commit will succeed and apply both changes -> Option D

4. Quick Check:

   Multiple ops allowed; last write wins [OK]

Hint: Batch allows multiple ops on same doc; last write applies [OK]

Common Mistakes:

• Thinking batch.update must come after batch.set
• Assuming batch.set overwrites cause errors
• Believing batch.update needs a callback

5. You want to update multiple user profiles atomically using batch writes. Which approach ensures all updates succeed or none apply?

hard

A. Use batch.set for each user document and commit once

B. Use batch.update for each user document and commit once

C. Use separate batch commits for each user document update

D. Use batch.delete for each user document before updating

Solution

1. Step 1: Understand atomic batch writes

   Batch writes commit all changes together; if one fails, none apply.

2. Step 2: Choose correct method for updating existing profiles

   batch.update modifies existing docs without overwriting all fields, suitable for updates.

3. Step 3: Analyze options

   Use batch.update for each user document and commit once uses batch.update for all users and commits once, ensuring atomicity.

4. Final Answer:

   Use batch.update for each user document and commit once -> Option B

5. Quick Check:

   batch.update + single commit = atomic update [OK]

Hint: Use batch.update and one commit for atomic multi-doc updates [OK]

Common Mistakes:

• Using multiple commits losing atomicity
• Using batch.set which overwrites entire documents
• Deleting docs before updating unnecessarily