Updating specific fields in Firebase - Time & Space Complexity

Time Complexity: Updating specific fields

O(1)

Understanding Time Complexity

When updating specific fields in a Firebase document, it's important to know how the time to complete the update changes as the number of fields or documents grows.

We want to understand how the update operation scales with input size.

Scenario Under Consideration

Analyze the time complexity of updating specific fields in a document.

const docRef = firestore.collection('users').doc('user123');
await docRef.update({
  age: 30,
  city: 'New York'
});
    

This code updates only the age and city fields of a single user document.

Identify Repeating Operations

Identify the API calls, resource provisioning, data transfers that repeat.

• Primary operation: One update API call to modify specific fields in a document.
• How many times: Exactly once per update request, regardless of how many fields are updated.

How Execution Grows With Input

Updating more fields in the same document still uses a single API call, so the number of calls stays the same.

Input Size (number of fields)	Approx. API Calls/Operations
2	1
10	1
100	1

Pattern observation: The number of API calls does not increase with the number of fields updated in a single document.

Final Time Complexity

Time Complexity: O(1)

This means updating specific fields in one document takes the same amount of time no matter how many fields you change.

Common Mistake

[X] Wrong: "Updating more fields means more API calls and longer time."

[OK] Correct: Because Firebase sends one update request per document, updating multiple fields in that document is done in a single call.

Interview Connect

Understanding how updates scale helps you design efficient data operations and shows you know how cloud services handle requests behind the scenes.

Self-Check

"What if we updated multiple documents instead of one? How would the time complexity change?"

Practice

1. What does the update() method do in Firebase Firestore?

easy

A. It creates a new collection in Firestore.

B. It deletes the entire document from the collection.

C. It changes only specific fields in a document without overwriting the whole document.

D. It reads all documents in a collection.

Solution

1. Step 1: Understand the purpose of update()

   The update() method modifies only the fields you specify in an existing document.

2. Step 2: Compare with other methods

   Unlike set(), update() does not overwrite the entire document, preserving other fields.

3. Final Answer:

   It changes only specific fields in a document without overwriting the whole document. -> Option C

4. Quick Check:

   update() modifies specific fields only [OK]

Hint: update() changes fields without replacing the whole document [OK]

Common Mistakes:

• Thinking update() deletes documents
• Confusing update() with set() creating collections
• Believing update() reads data

2. Which of the following is the correct syntax to update the field age to 30 in a Firestore document reference docRef?

easy

A. docRef.update({ age: 30 });

B. docRef.set({ age: 30 });

C. docRef.update(age = 30);

D. docRef.modify({ age: 30 });

Solution

1. Step 1: Identify the correct method for updating fields

   The update() method is used to change specific fields without overwriting the document.

2. Step 2: Check syntax correctness

   The correct syntax is docRef.update({ age: 30 }); where the fields to update are passed as an object.

3. Final Answer:

   docRef.update({ age: 30 }); -> Option A

4. Quick Check:

   update() uses object with fields [OK]

Hint: Use update() with an object to change fields [OK]

Common Mistakes:

• Using set() which overwrites the document
• Using invalid syntax like update(age = 30)
• Using non-existent method modify()

3. Given this code snippet:

const docRef = firestore.collection('users').doc('user123');
docRef.update({ 'profile.name': 'Alice', 'profile.age': 28 });

What will happen if the document user123 does not exist?

medium

A. The update will fail with an error because the document does not exist.

B. The update will silently do nothing and return success.

C. The update will create the document with the specified fields.

D. The update will overwrite the entire document with the new fields.

Solution

1. Step 1: Understand update() behavior on non-existing documents

   The update() method requires the document to exist; otherwise, it throws an error.

2. Step 2: Analyze the code context

   Since user123 does not exist, the update call will fail with an error.

3. Final Answer:

   The update will fail with an error because the document does not exist. -> Option A

4. Quick Check:

   update() fails if document missing [OK]

Hint: update() needs existing document; else error occurs [OK]

Common Mistakes:

• Assuming update() creates documents
• Thinking update() silently succeeds
• Confusing update() with set() with merge

4. You try to update a nested field using this code:

docRef.update({ 'address.city': 'New York' });

But you get an error. What is the most likely cause?

medium

A. Dot notation is not supported for nested fields in update().

B. The document does not exist, so update() fails.

C. You must use set() instead of update() for nested fields.

D. The field name 'address.city' is invalid in Firestore.

Solution

1. Step 1: Recall update() requirements

   update() requires the document to exist; otherwise, it throws an error.

2. Step 2: Check dot notation support

   Dot notation is supported for nested fields in update(), so that is not the cause.

3. Step 3: Confirm field name validity

   Field names with dot notation are valid in Firestore for nested updates.

4. Final Answer:

   The document does not exist, so update() fails. -> Option B

5. Quick Check:

   update() fails if document missing, dot notation allowed [OK]

Hint: update() fails if document missing; dot notation is valid [OK]

Common Mistakes:

• Believing dot notation is unsupported
• Thinking set() is required for nested fields
• Assuming field names with dots are invalid

5. You want to update the nested field settings.notifications.email to false in a Firestore document. The document may or may not exist. Which code snippet correctly updates or creates the document without overwriting other fields?

hard

A. docRef.update({ 'settings.notifications.email': false });

B. docRef.set({ 'settings.notifications.email': false });

C. docRef.update({ settings: { notifications: { email: false } } });

D. docRef.set({ 'settings.notifications.email': false }, { merge: true });

Solution

1. Step 1: Understand update() vs set() with merge

   update() fails if the document does not exist. set() with { merge: true } creates or updates without overwriting.

2. Step 2: Analyze each option

   docRef.update({ 'settings.notifications.email': false }); fails if document missing. docRef.set({ 'settings.notifications.email': false }); overwrites entire document. docRef.set({ 'settings.notifications.email': false }, { merge: true }); correctly merges nested field. docRef.update({ settings: { notifications: { email: false } } }); incorrectly uses update() with nested object, which overwrites nested fields.

3. Final Answer:

   docRef.set({ 'settings.notifications.email': false }, { merge: true }); -> Option D

4. Quick Check:

   Use set() with merge:true to update or create safely [OK]

Hint: Use set() with merge:true to update nested fields safely [OK]

Common Mistakes:

• Using update() when document may not exist
• Using set() without merge, overwriting data
• Passing nested objects to update() causing overwrite