Transaction read-then-write pattern in Firebase - Step-by-Step Execution

Process Flow - Transaction read-then-write pattern

Start Transaction

↓

Read current data

↓

Check or calculate new data

↓

Write updated data

↓

Commit Transaction

↓

End Transaction

This flow shows how a transaction reads data first, then writes updated data, ensuring consistency.

Execution Sample

Firebase

db.runTransaction(transaction => {
  return transaction.get(docRef).then(doc => {
    const newCount = doc.data().count + 1;
    transaction.update(docRef, { count: newCount });
  });
});

This code reads a document's count, increments it by one, and writes it back atomically.

Process Table

Step	Action	Data Read	Data Written	Transaction State
1	Start transaction	N/A	N/A	Open
2	Read document	{ count: 5 }	N/A	Open
3	Calculate new count	5	N/A	Open
4	Write updated count	N/A	{ count: 6 }	Open
5	Commit transaction	N/A	Committed { count: 6 }	Committed
6	End transaction	N/A	N/A	Closed

💡 Transaction ends after commit, ensuring atomic read-modify-write.

Status Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
count	undefined	5	5	6	6
transactionState	Not started	Open	Open	Open	Committed

Key Moments - 2 Insights

Why do we read data before writing in a transaction?

Because the transaction needs the current data to calculate the new value before writing, as shown in step 2 and 3 of the execution table.

What happens if the data changes between read and write?

The transaction automatically retries to ensure consistency, so the read-then-write pattern always works with the latest data, as implied by the transaction state in the table.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'count' after step 3?

A 5

B 6

C undefined

D N/A

💡 Hint

Check the 'Data Read' and 'Data Written' columns at step 3 in the execution table.

At which step does the transaction commit the new data?

A Step 2

B Step 5

C Step 4

D Step 6

💡 Hint

Look at the 'Transaction State' column for the 'Committed' status in the execution table.

If the initial count was 10 instead of 5, what would be the 'Data Written' at step 4?

A { count: 5 }

B { count: 6 }

C { count: 11 }

D { count: 10 }

💡 Hint

Refer to the variable_tracker for how 'count' changes after calculation.

Concept Snapshot

Transaction read-then-write pattern:
- Start a transaction
- Read current data inside transaction
- Calculate new data based on read
- Write updated data
- Commit transaction atomically
Ensures data consistency and avoids conflicts.

Full Transcript

This visual execution shows the transaction read-then-write pattern in Firebase. The transaction starts, reads the current document data (count = 5), calculates the new count (5 + 1 = 6), writes the updated count, commits the transaction, and ends. Variables like 'count' and 'transactionState' change step by step. Key points include reading before writing to get current data and committing atomically to avoid conflicts. The quizzes test understanding of variable values at steps and transaction commit timing.

Practice

1. What is the main purpose of using a transaction in Firebase when updating data?

easy

A. To speed up data retrieval from the database

B. To store data permanently without changes

C. To safely read and write data together without conflicts

D. To delete data automatically after a set time

Solution

1. Step 1: Understand transaction role

   Transactions allow reading and writing data atomically, meaning both happen together safely.

2. Step 2: Identify conflict prevention

   This prevents conflicts when multiple users try to update the same data at once.

3. Final Answer:

   To safely read and write data together without conflicts -> Option C

4. Quick Check:

   Transaction = safe read-write [OK]

Hint: Transactions combine read and write safely [OK]

Common Mistakes:

• Thinking transactions only speed up reads
• Assuming transactions delete data
• Believing transactions store data permanently without changes

2. Which of the following is the correct syntax to start a transaction in Firebase Firestore using JavaScript?

easy

A. db.startTransaction(() => { /* code */ })

B. db.transactionStart(() => { /* code */ })

C. db.beginTransaction(async () => { /* code */ })

D. db.runTransaction(async (transaction) => { /* code */ })

Solution

1. Step 1: Recall Firestore transaction syntax

   The correct method to run a transaction is db.runTransaction with an async callback.

2. Step 2: Check other options

   Other options like transactionStart, beginTransaction, or startTransaction are not valid Firestore methods.

3. Final Answer:

   db.runTransaction(async (transaction) => { /* code */ }) -> Option D

4. Quick Check:

   runTransaction is correct method [OK]

Hint: Use db.runTransaction with async callback [OK]

Common Mistakes:

• Using non-existent methods like transactionStart
• Forgetting async keyword in callback
• Confusing transaction syntax with other database APIs

3. Given this transaction code snippet, what will be the final value of the 'count' field if the document initially has count = 5?

db.runTransaction(async (transaction) => {
  const docRef = db.collection('counters').doc('counter1');
  const doc = await transaction.get(docRef);
  if (!doc.exists) {
    transaction.set(docRef, { count: 1 });
  } else {
    const newCount = doc.data().count + 1;
    transaction.update(docRef, { count: newCount });
  }
});

medium

A. 6

B. 1

C. 5

D. 0

Solution

1. Step 1: Check if document exists

   The document exists with count = 5, so the else block runs.

2. Step 2: Calculate new count

   New count is 5 + 1 = 6, and transaction updates the document with this value.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Existing count + 1 = 6 [OK]

Hint: If doc exists, increment count by 1 [OK]

Common Mistakes:

• Assuming count resets to 1 even if doc exists
• Forgetting to add 1 to existing count
• Confusing set and update behavior

4. Identify the error in this transaction code snippet:

db.runTransaction(async (transaction) => {
  const docRef = db.collection('items').doc('item1');
  const doc = await transaction.get(docRef);
  const currentStock = doc.data().stock;
  if (currentStock > 0) {
    transaction.update(docRef, { stock: currentStock - 1 });
  }
});

medium

A. Missing check if document exists before accessing data

B. Using transaction.update instead of transaction.set

C. Not awaiting transaction.update call

D. Incorrect collection name syntax

Solution

1. Step 1: Check document existence

   The code accesses doc.data().stock without verifying if doc.exists, which can cause errors if doc is missing.

2. Step 2: Confirm other parts

   transaction.update is correct for partial update, awaiting update is not needed as transaction methods handle it, and collection name syntax is correct.

3. Final Answer:

   Missing check if document exists before accessing data -> Option A

4. Quick Check:

   Always check doc.exists before data [OK]

Hint: Always check doc.exists before reading data [OK]

Common Mistakes:

• Skipping doc.exists check causing runtime errors
• Confusing update with set methods
• Expecting to await transaction.update explicitly

5. You want to implement a transaction that increments a user's score only if the current score is less than 100. Which of the following code snippets correctly applies the transaction read-then-write pattern to achieve this?

hard

A. db.runTransaction(async (transaction) => {
const userRef = db.collection('users').doc('user1');
const doc = await transaction.get(userRef);
if (doc.data().score < 100) {
transaction.set(userRef, { score: doc.data().score + 1 });
}
});

B. db.runTransaction(async (transaction) => {
const userRef = db.collection('users').doc('user1');
const doc = await transaction.get(userRef);
if (doc.exists && doc.data().score < 100) {
transaction.update(userRef, { score: doc.data().score + 1 });
}
});

C. db.runTransaction(async (transaction) => {
const userRef = db.collection('users').doc('user1');
const doc = await transaction.get(userRef);
transaction.update(userRef, { score: 100 });
});

D. db.runTransaction(async (transaction) => {
const userRef = db.collection('users').doc('user1');
transaction.update(userRef, { score: 1 });
});

Solution

1. Step 1: Check document existence and condition

   db.runTransaction(async (transaction) => { const userRef = db.collection('users').doc('user1'); const doc = await transaction.get(userRef); if (doc.exists && doc.data().score < 100) { transaction.update(userRef, { score: doc.data().score + 1 }); } }); correctly checks if the document exists and if the score is less than 100 before updating.

2. Step 2: Verify update method and logic

   It uses transaction.update to increment the score by 1 only when condition is met, preserving existing data.

3. Final Answer:

   db.runTransaction(async (transaction) => { const userRef = db.collection('users').doc('user1'); const doc = await transaction.get(userRef); if (doc.exists && doc.data().score < 100) { transaction.update(userRef, { score: doc.data().score + 1 }); } }); -> Option B

4. Quick Check:

   Check exists + condition before update [OK]

Hint: Check doc exists and condition before update [OK]

Common Mistakes:

• Not checking if doc exists before reading data
• Using set instead of update causing overwrite
• Updating without condition or setting fixed value