Array update with $[identifier] filtered in MongoDB - Time & Space Complexity

Time Complexity: Array update with $[identifier] filtered

O(n)

Understanding Time Complexity

When updating elements inside an array in MongoDB using the $[identifier] filtered positional operator, it's important to understand how the operation's cost changes as the array grows.

We want to know how the time to update scales when the array inside documents gets larger.

Scenario Under Consideration

Analyze the time complexity of the following MongoDB update operation.

db.collection.updateMany(
  { "items.status": "pending" },
  { $set: { "items.$[elem].status": "complete" } },
  { arrayFilters: [ { "elem.status": "pending" } ] }
)
    

This code updates all documents where the array 'items' has elements with status 'pending'. It sets those elements' status to 'complete' using a filtered positional operator.

Identify Repeating Operations

Look at what repeats inside the update:

• Primary operation: Scanning each element in the 'items' array to check if it matches the filter condition.
• How many times: For each document matched, the operation checks every element in the 'items' array once.

How Execution Grows With Input

The time to update grows as the number of elements in the 'items' array grows.

Input Size (n)	Approx. Operations
10	About 10 checks per document
100	About 100 checks per document
1000	About 1000 checks per document

Pattern observation: The number of operations grows roughly in direct proportion to the array size.

Final Time Complexity

Time Complexity: O(n)

This means the update time grows linearly with the number of elements in the array being filtered.

Common Mistake

[X] Wrong: "The update only touches the matching elements, so it runs in constant time regardless of array size."

[OK] Correct: MongoDB must check each array element to find matches, so the time depends on how many elements there are, not just the matches.

Interview Connect

Understanding how array updates scale helps you explain database performance clearly and shows you know how MongoDB handles array filters under the hood.

Self-Check

What if we changed the array filter to match multiple fields or nested arrays? How would the time complexity change?

Practice

1. What does the $[identifier] syntax do in a MongoDB update operation?

easy

A. It updates only the array elements that match the filter specified in arrayFilters.

B. It deletes the entire array from the document.

C. It adds a new element to the array without any condition.

D. It replaces the whole document with a new one.

Solution

1. Step 1: Understand $[identifier] usage

   The $[identifier] syntax is used to target specific elements inside an array during an update.

2. Step 2: Role of arrayFilters

   The arrayFilters option specifies which array elements the $[identifier] refers to, so only those elements get updated.

3. Final Answer:

   It updates only the array elements that match the filter specified in arrayFilters. -> Option A

4. Quick Check:

   $[identifier] updates filtered array items [OK]

Hint: Remember: $[id] updates filtered array elements only [OK]

Common Mistakes:

• Thinking $[identifier] updates the whole array
• Confusing $[identifier] with $push or $set without filters
• Ignoring the need for arrayFilters option

2. Which of the following is the correct syntax to update array elements using $[elem] with arrayFilters in MongoDB?

easy

A. db.collection.updateOne({},{ $set: { 'array.$[elem]': value } }, { arrayFilters: [ { 'elem.field': condition } ] })

B. db.collection.updateOne({},{ $push: { 'array.$[elem]': value } }, { arrayFilters: [ { 'elem.field': condition } ] })

C. db.collection.updateOne({},{ $set: { 'array.$elem': value } }, { arrayFilters: [ { 'elem.field': condition } ] })

D. db.collection.updateOne({},{ $set: { 'array.$[elem]': value } })

Solution

1. Step 1: Identify correct update operator and syntax

   The $set operator is used to update existing fields. The positional filtered identifier must be inside square brackets like $[elem].

2. Step 2: Confirm usage of arrayFilters

   The arrayFilters option must be provided with a filter object matching the identifier used inside $[elem].

3. Final Answer:

   db.collection.updateOne({},{ $set: { 'array.$[elem]': value } }, { arrayFilters: [ { 'elem.field': condition } ] }) -> Option A

4. Quick Check:

   Use $set with $[elem] and arrayFilters [OK]

Hint: Use $set with $[identifier] and arrayFilters together [OK]

Common Mistakes:

• Using $push instead of $set for updates
• Missing square brackets around identifier
• Not providing arrayFilters option

3. Given the collection document:

{ _id: 1, scores: [ { type: 'quiz', score: 5 }, { type: 'exam', score: 8 }, { type: 'quiz', score: 7 } ] }

What will be the result of this update?

db.collection.updateOne({ _id: 1 }, { $set: { 'scores.$[elem].score': 10 } }, { arrayFilters: [ { 'elem.type': 'quiz' } ] })

What will the scores array look like after the update?

medium

A. [ { type: 'quiz', score: 5 }, { type: 'exam', score: 8 }, { type: 'quiz', score: 7 } ]

B. [ { type: 'quiz', score: 10 }, { type: 'exam', score: 10 }, { type: 'quiz', score: 10 } ]

C. [ { type: 'quiz', score: 10 }, { type: 'exam', score: 8 }, { type: 'quiz', score: 7 } ]

D. [ { type: 'quiz', score: 10 }, { type: 'exam', score: 8 }, { type: 'quiz', score: 10 } ]

Solution

1. Step 1: Identify which array elements match the filter

   The filter { 'elem.type': 'quiz' } matches the first and third elements in the scores array.

2. Step 2: Apply the update to matched elements only

   The score field of these matched elements is set to 10, while the second element remains unchanged.

3. Final Answer:

   [ { type: 'quiz', score: 10 }, { type: 'exam', score: 8 }, { type: 'quiz', score: 10 } ] -> Option D

4. Quick Check:

   Only 'quiz' type scores updated to 10 [OK]

Hint: Only elements matching arrayFilters get updated [OK]

Common Mistakes:

• Updating all elements ignoring arrayFilters
• Updating wrong elements by misreading filter
• Expecting update without arrayFilters to work

4. You run this update:

db.collection.updateOne({ _id: 1 }, { $set: { 'items.$[i].status': 'sold' } }, { arrayFilters: [ { 'item.status': 'available' } ] })

But no documents are updated. What is the most likely cause?

medium

A. The $set operator cannot be used with $[i].

B. The query filter {_id: 1} is incorrect.

C. The identifier in arrayFilters does not match the one in the update query.

D. MongoDB does not support arrayFilters in updateOne.

Solution

1. Step 1: Check identifier consistency

   The update uses $[i] but the arrayFilters uses item. These must match exactly.

2. Step 2: Understand effect of mismatch

   Because the identifiers differ, MongoDB cannot apply the filter, so no elements are updated.

3. Final Answer:

   The identifier in arrayFilters does not match the one in the update query. -> Option C

4. Quick Check:

   Identifier names must match in update and arrayFilters [OK]

Hint: Match identifier names exactly in update and arrayFilters [OK]

Common Mistakes:

• Using different names for identifier and filter variable
• Assuming $set can't work with $[identifier]
• Blaming query filter without checking arrayFilters

5. You have documents with an array field tasks where each task has status and priority. You want to update only tasks with status: 'pending' and priority greater than 5, setting their status to 'in-progress'. Which update command correctly does this?

hard

A. db.collection.updateMany({}, { $set: { 'tasks.$.status': 'in-progress' } }, { arrayFilters: [ { 't.status': 'pending', 't.priority': { $gt: 5 } } ] })

B. db.collection.updateMany({}, { $set: { 'tasks.$[t].status': 'in-progress' } }, { arrayFilters: [ { 't.status': 'pending', 't.priority': { $gt: 5 } } ] })

C. db.collection.updateMany({}, { $set: { 'tasks.$[t].status': 'in-progress' } }, { arrayFilters: [ { 't.status': 'pending' && 't.priority': { $gt: 5 } } ] })

D. db.collection.updateMany({}, { $set: { 'tasks.$[t].status': 'in-progress' } }, { arrayFilters: [ { 't.status': 'pending' }, { 'u.priority': { $gt: 5 } } ] })

Solution

1. Step 1: Use a single filter object combining conditions

   The arrayFilters option must have one object combining both conditions with commas, meaning AND logic.

2. Step 2: Use correct identifier and update syntax

   The update uses $[t] matching the filter identifier t, and $set to update the status field.

3. Final Answer:

   db.collection.updateMany({}, { $set: { 'tasks.$[t].status': 'in-progress' } }, { arrayFilters: [ { 't.status': 'pending', 't.priority': { $gt: 5 } } ] }) -> Option B

4. Quick Check:

   Combine conditions in one filter object with matching identifier [OK]

Hint: Combine multiple conditions in one arrayFilter object [OK]

Common Mistakes:

• Splitting conditions into multiple filter objects (no AND)
• Using logical operators incorrectly inside arrayFilters
• Using positional $ instead of filtered $[identifier]