Array expressions ($size, $arrayElemAt, $filter) in MongoDB - Time & Space Complexity

Time Complexity: Array expressions ($size, $arrayElemAt, $filter)

O(n)

Understanding Time Complexity

When working with arrays in MongoDB, it's important to know how the time to process them grows as the array gets bigger.

We want to understand how operations like counting elements, picking one element, or filtering affect performance as the array size increases.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

    db.collection.aggregate([
      {
        $project: {
          totalItems: { $size: "$items" },
          firstItem: { $arrayElemAt: ["$items", 0] },
          filteredItems: { $filter: {
            input: "$items",
            as: "item",
            cond: { $gt: ["$$item.price", 100] }
          }}
        }
      }
    ])
    

This code counts the number of items, gets the first item, and filters items with price over 100 in each document.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Traversing the array to filter items.
• How many times: The filter checks each element once, so it runs once per item in the array.

How Execution Grows With Input

Explain the growth pattern intuitively.

Input Size (n)	Approx. Operations
10	About 10 checks for filtering, plus 1 for size and 1 for first element
100	About 100 checks for filtering, plus 1 for size and 1 for first element
1000	About 1000 checks for filtering, plus 1 for size and 1 for first element

Pattern observation: The filtering work grows directly with the number of items, while size and first element are quick constant-time operations.

Final Time Complexity

Time Complexity: O(n)

This means the time to run this aggregation grows linearly with the number of items in the array.

Common Mistake

[X] Wrong: "Getting the size or first element of an array takes as long as filtering all items."

[OK] Correct: Counting elements or picking one element is very fast and does not depend on array size, unlike filtering which checks each item.

Interview Connect

Understanding how array operations scale helps you write efficient queries and explain your choices clearly in interviews.

Self-Check

"What if we changed the filter condition to check nested arrays inside each item? How would the time complexity change?"

Practice

1. What does the MongoDB expression $size do when used on an array field?

easy

A. Counts how many elements are in the array

B. Returns the first element of the array

C. Filters elements based on a condition

D. Sorts the array elements

Solution

1. Step 1: Understand the purpose of $size

   The $size operator counts the number of elements inside an array.

2. Step 2: Compare with other operators

   $arrayElemAt picks an element by position, $filter selects elements by condition, and sorting is unrelated.

3. Final Answer:

   Counts how many elements are in the array -> Option A

4. Quick Check:

   $size = count elements [OK]

Hint: Remember $size counts array length, not elements themselves [OK]

Common Mistakes:

• Confusing $size with $arrayElemAt
• Thinking $size filters elements
• Assuming $size sorts arrays

2. Which of the following is the correct syntax to get the third element of an array field named items using MongoDB aggregation?

easy

A. { $arrayElemAt: ["items", 3] }

B. { $size: ["$items", 2] }

C. { $arrayElemAt: ["$items", 2] }

D. { $filter: { input: "$items", as: "item", cond: { $eq: ["$$item", 2] } } }

Solution

1. Step 1: Recall zero-based indexing in $arrayElemAt

   The third element is at index 2 because counting starts at 0.

2. Step 2: Check syntax correctness

   The correct syntax uses $arrayElemAt with the array field prefixed by $ and the zero-based index.

3. Final Answer:

   { $arrayElemAt: ["$items", 2] } -> Option C

4. Quick Check:

   Third element index = 2 [OK]

Hint: Remember arrays start at 0, so third element is index 2 [OK]

Common Mistakes:

• Using 1-based index instead of 0-based
• Missing $ before field name
• Confusing $size with $arrayElemAt

3. Given the document { scores: [10, 20, 30, 40] }, what will the aggregation expression { $size: "$scores" } return?

medium

A. 4

B. 30

C. [10, 20, 30, 40]

D. Error

Solution

1. Step 1: Understand what $size does

   $size counts the number of elements in the array.

2. Step 2: Count elements in the array

   The array [10, 20, 30, 40] has 4 elements.

3. Final Answer:

   4 -> Option A

4. Quick Check:

   Array length = 4 [OK]

Hint: Count elements inside brackets for $size result [OK]

Common Mistakes:

• Returning the third element instead of count
• Returning the whole array instead of count
• Assuming syntax error

4. Identify the error in this MongoDB aggregation expression: { $arrayElemAt: ["$values", "1"] }

medium

A. Field name missing $ prefix

B. Index must be a number, not a string

C. Array must be inside an object

D. No error, expression is correct

Solution

1. Step 1: Check the type of index in $arrayElemAt

   The index must be a number, but here it is a string "1".

2. Step 2: Confirm correct field referencing

   The field name "$values" is correctly prefixed with $.

3. Final Answer:

   Index must be a number, not a string -> Option B

4. Quick Check:

   Index type = number, not string [OK]

Hint: Use number type for index in $arrayElemAt [OK]

Common Mistakes:

• Using string instead of number for index
• Omitting $ before field name
• Thinking array must be wrapped differently

5. You have documents with a field tags as an array of strings. How would you write a MongoDB aggregation expression to get the count of tags that start with the letter 'a'?

hard

A. { $size: "$tags" }

B. { $arrayElemAt: ["$tags", 0] }

C. { $filter: { input: "$tags", as: "tag", cond: { $eq: ["$$tag", "a"] } } }

D. { $size: { $filter: { input: "$tags", as: "tag", cond: { $regexMatch: { input: "$$tag", regex: /^a/ } } } } }

Solution

1. Step 1: Use $filter to select tags starting with 'a'

   The $filter operator creates a new array with tags matching the regex /^a/.

2. Step 2: Use $size to count filtered tags

   $size counts how many tags matched the condition.

3. Final Answer:

   { $size: { $filter: { input: "$tags", as: "tag", cond: { $regexMatch: { input: "$$tag", regex: /^a/ } } } } } -> Option D

4. Quick Check:

   Filter then count = correct approach [OK]

Hint: Filter first, then count with $size for conditional counts [OK]

Common Mistakes:

• Using $arrayElemAt instead of $filter
• Filtering with exact match instead of regex
• Counting whole array without filtering