Increment operations in Firebase - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ service_behavior

intermediate

Incrementing a Firestore field atomically

You want to increase a numeric field likes in a Firestore document by 1 without overwriting other fields. Which code snippet correctly performs this atomic increment?

Firebase

const docRef = firestore.collection('posts').doc('post1');

// Which option correctly increments 'likes' by 1?

A docRef.update({ likes: likes + 1 });

B docRef.set({ likes: likes + 1 });

C docRef.set({ likes: firebase.firestore.FieldValue.increment(1) });

D docRef.update({ likes: firebase.firestore.FieldValue.increment(1) });

💡 Hint

Use Firestore's atomic increment operation to avoid race conditions.

Option D uses FieldValue.increment(1) which atomically increases the likes field without overwriting other fields. Options A and B assume you have the current value locally, which can cause race conditions. Option D overwrites the entire document, which is not desired.

❓ Configuration

intermediate

Configuring Firebase Realtime Database for atomic increments

In Firebase Realtime Database, which method correctly increments a numeric value at path /counters/visits atomically?

Firebase

const ref = firebase.database().ref('/counters/visits');

// Choose the correct increment method

A ref.increment(1);

B ref.set(ref.val() + 1);

C ref.transaction(current => (current || 0) + 1);

D ref.update({ visits: ref.val() + 1 });

💡 Hint

Use a transaction to safely update values in Realtime Database.

Option C uses a transaction function that reads the current value and increments it atomically. Options B and C try to read and write without atomicity, risking race conditions. Option C is invalid as increment is not a Realtime Database method.

❓ Architecture

advanced

Designing scalable counters with Firestore increments

You expect very high traffic incrementing a counter in Firestore. Which architecture best avoids contention and throttling?

A Use a single document with <code>FieldValue.increment(1)</code> for all increments.

B Use multiple shard documents each incremented independently, then aggregate counts.

C Use Firestore batch writes to update the counter document every 100 increments.

D Use Firestore transactions to read and write the counter document on each increment.

💡 Hint

Think about how to reduce write contention on a single document.

Option B shards the counter across multiple documents to distribute writes, reducing contention and throttling. Option B risks contention on a single document. Option B delays increments but still writes to one document. Option B causes contention due to repeated read-write cycles.

❓ security

advanced

Securing increment operations in Firestore rules

Which Firestore security rule snippet correctly allows increments on a likes field but prevents arbitrary overwrites?

Firebase

match /posts/{postId} {
  allow update: if ... ;
}

A request.resource.data.likes == resource.data.likes + 1 && request.resource.data.diff(resource.data).affectedKeys().hasOnly(['likes']);

B request.resource.data.likes > resource.data.likes;

C request.resource.data.likes == resource.data.likes + 1;

D request.resource.data.keys().hasOnly(['likes']);

💡 Hint

Ensure only the likes field changes and it increments by exactly 1.

Option A checks that only the likes field changes and that it increments by exactly 1. Option A allows any increase but not restricting other fields. Option A does not restrict other fields. Option A restricts fields but not the increment logic.

✅ Best Practice

expert

Choosing the best method for high-frequency increments in Firebase

You need to implement a view counter that increments thousands of times per second in Firebase. Which approach is best to ensure accuracy, scalability, and minimal cost?

A Implement sharded counters in Firestore with periodic aggregation via Cloud Functions.

B Use Realtime Database transactions on a single counter node for each view.

C Store each view as a separate document and count them with a query.

D Use Firestore <code>FieldValue.increment(1)</code> on a single document for each view.

💡 Hint

Consider write limits and cost efficiency for very high write rates.

Option A shards counters to distribute writes and uses Cloud Functions to aggregate counts, balancing scalability and cost. Option A risks contention and throttling. Option A faces similar contention issues. Option A is costly and inefficient for counting.