Why atomic operations ensure consistency in Firebase - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to perform an atomic update on a Firestore document.

Firebase

db.collection('users').doc('user1').[1]({ age: 30 });

Drag options to blanks, or click blank then click option'

Adelete

Bget

Cset

Dupdate

Attempts:

3 left

💡 Hint

Common Mistakes

Using set() overwrites the whole document, not atomic update.

The update method performs an atomic update on the document, ensuring consistency.

2fill in blank

medium

Complete the code to run a transaction that increments a counter atomically.

Firebase

db.runTransaction(async (transaction) => {
  const doc = await transaction.get(docRef);
  const newCount = doc.data().count + [1];
  transaction.update(docRef, { count: newCount });
});

Drag options to blanks, or click blank then click option'

A1

B-1

C0

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 does not change the count.

Using negative numbers decreases the count.

Incrementing by 1 is a common atomic operation to increase counters safely.

3fill in blank

hard

Fix the error in the transaction code to ensure atomicity.

Firebase

db.runTransaction(async (transaction) => {
  const doc = await transaction.get(docRef);
  const newBalance = doc.data().balance [1] 100;
  transaction.update(docRef, { balance: newBalance });
});

Drag options to blanks, or click blank then click option'

A-

B+

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using + increases balance incorrectly.

Using * or / changes balance unexpectedly.

Subtracting 100 from the balance atomically ensures consistency when deducting funds.

4fill in blank

hard

Fill both blanks to atomically increment and check a value in Firestore.

Firebase

db.runTransaction(async (transaction) => {
  const doc = await transaction.get(docRef);
  if (doc.data().stock [1] 0) {
    transaction.update(docRef, { stock: doc.data().stock [2] 1 });
  }
});

Drag options to blanks, or click blank then click option'

A>

B+

C-

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > causes wrong condition.

Using + instead of - increases stock incorrectly.

The code checks if stock is greater than 0, then subtracts 1 atomically to reduce stock.

5fill in blank

hard

Fill all three blanks to atomically update multiple fields in a Firestore document.

Firebase

db.runTransaction(async (transaction) => {
  const doc = await transaction.get(docRef);
  transaction.update(docRef, {
    balance: doc.data().balance [1] 50,
    points: doc.data().points [2] 10,
    status: [3]
  });
});

Drag options to blanks, or click blank then click option'

A+

B-

C'active'

D'inactive'

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong operators changes values incorrectly.

Setting status to 'inactive' is not intended here.

The transaction adds 50 to balance, subtracts 10 from points, and sets status to 'active' atomically.

Practice

1. Why do atomic operations help keep data consistent in Firebase?

easy

A. Because they make sure all parts of a change happen together or not at all

B. Because they allow multiple users to edit data at the same time without limits

C. Because they speed up data retrieval from the database

D. Because they automatically back up data every minute

Solution

1. Step 1: Understand atomic operation meaning

   Atomic operations mean changes happen fully or not at all, avoiding partial updates.

2. Step 2: Connect atomicity to data consistency

   This ensures data stays correct even if many users update at once, preventing errors.

3. Final Answer:

   Because they make sure all parts of a change happen together or not at all -> Option A

4. Quick Check:

   Atomic = all-or-nothing update [OK]

Hint: Atomic means all-or-nothing update to keep data correct [OK]

Common Mistakes:

• Thinking atomic operations allow unlimited simultaneous edits
• Confusing atomicity with faster data retrieval
• Assuming atomic operations create automatic backups

2. Which Firebase syntax correctly starts a transaction to update a value atomically?

easy

A. firebase.database().ref('count').transaction(current => current + 1)

B. firebase.database().ref('count').update(current + 1)

C. firebase.database().ref('count').set(current + 1)

D. firebase.database().ref('count').push(current + 1)

Solution

1. Step 1: Identify transaction syntax in Firebase

   The transaction method takes a function to update the current value atomically.

2. Step 2: Compare options to transaction usage

   Only firebase.database().ref('count').transaction(current => current + 1) uses .transaction() with a function to increment the value safely.

3. Final Answer:

   firebase.database().ref('count').transaction(current => current + 1) -> Option A

4. Quick Check:

   Use .transaction() with a function for atomic update [OK]

Hint: Use .transaction() with a function to update atomically [OK]

Common Mistakes:

• Using .update() or .set() which are not atomic
• Using .push() which adds new data, not update atomically
• Passing a value instead of a function to .transaction()

3. What will be the final value of 'likes' after this Firebase transaction code runs if the initial value is 5?

firebase.database().ref('likes').transaction(current => {
  if (current === null) return 1;
  return current + 2;
});

medium

A. 5

B. 7

C. 1

D. null

Solution

1. Step 1: Check initial value and transaction logic

   Initial 'likes' is 5, so current is 5, not null.

2. Step 2: Apply transaction function

   Since current is 5, function returns 5 + 2 = 7.

3. Final Answer:

   7 -> Option B

4. Quick Check:

   5 + 2 = 7 after transaction [OK]

Hint: Add 2 to current if not null, else set 1 [OK]

Common Mistakes:

• Assuming initial value is null and returning 1
• Ignoring the +2 increment
• Confusing return values with no update

4. A developer wrote this Firebase transaction code but it sometimes causes incorrect counts:

firebase.database().ref('count').transaction(current => current + 1);

What is the likely problem?

medium

A. The code should use .set() instead of .transaction()

B. The transaction method is not atomic

C. The transaction function does not handle null initial values

D. The database reference path is incorrect

Solution

1. Step 1: Analyze transaction function behavior

   If 'current' is null (no value yet), current + 1 causes error or NaN.

2. Step 2: Identify missing null check

   Function should check if current is null and return 1 to start counting correctly.

3. Final Answer:

   The transaction function does not handle null initial values -> Option C

4. Quick Check:

   Always check for null in transaction function [OK]

Hint: Check for null before adding in transaction function [OK]

Common Mistakes:

• Thinking transaction is not atomic
• Replacing transaction with .set() which is not atomic
• Assuming path is wrong without evidence

5. You want to update a shared 'stock' count in Firebase safely when many users buy items simultaneously. Which approach best ensures the stock count stays accurate?

hard

A. Use .push() to add each purchase as a new entry without updating stock

B. Use .set() to overwrite the stock count with the new value directly

C. Use .update() with the new stock value without reading current stock

D. Use a transaction that reads the current stock, subtracts the purchase amount, and writes back atomically

Solution

1. Step 1: Understand the problem of concurrent updates

   Multiple users buying at once can cause race conditions if stock is overwritten without checking current value.

2. Step 2: Choose atomic update method

   Using a transaction reads current stock, applies subtraction, and writes back atomically, preventing conflicts.

3. Final Answer:

   Use a transaction that reads the current stock, subtracts the purchase amount, and writes back atomically -> Option D

4. Quick Check:

   Atomic transaction ensures accurate shared stock update [OK]

Hint: Use transaction to read-modify-write shared data safely [OK]

Common Mistakes:

• Overwriting stock without reading current value
• Adding purchases without updating stock count
• Using .update() without atomicity