Attribute pattern for variable fields in MongoDB - Time & Space Complexity

Time Complexity: Attribute pattern for variable fields

O(n)

Understanding Time Complexity

When working with variable fields in MongoDB documents, queries often use attribute patterns to find matching fields.

We want to understand how the time to run these queries changes as the data grows.

Scenario Under Consideration

Analyze the time complexity of the following MongoDB query using attribute pattern matching.

db.collection.find({
  "attributes.color": { $exists: true },
  "attributes.size": { $exists: true }
})
.limit(100)

This query finds documents where the "attributes" object has both "color" and "size" fields.

Identify Repeating Operations

Look for repeated checks or scans in the query process.

• Primary operation: Scanning each document to check if the "attributes" object contains the specified fields.
• How many times: Once per document in the collection until 100 matches are found or all documents are checked.

How Execution Grows With Input

As the number of documents grows, the query must check more documents to find matches.

Input Size (n)	Approx. Operations
10	Up to 10 document checks
100	Up to 100 document checks
1000	Up to 1000 document checks

Pattern observation: The number of checks grows roughly in direct proportion to the number of documents.

Final Time Complexity

Time Complexity: O(n)

This means the time to run the query grows linearly with the number of documents in the collection.

Common Mistake

[X] Wrong: "The query will always be fast because it only looks for two fields."

[OK] Correct: Even though the query looks for two fields, MongoDB must check each document's attributes, so the time depends on how many documents there are.

Interview Connect

Understanding how queries with variable fields scale helps you explain performance and indexing strategies clearly in real-world situations.

Self-Check

What if we added an index on "attributes.color" and "attributes.size"? How would the time complexity change?

Practice

1. In MongoDB, which operator helps you find documents where a field's value matches a text pattern?

easy

A. $match

B. $regex

C. $group

D. $project

Solution

1. Step 1: Understand pattern matching in MongoDB

   MongoDB uses $regex to match string patterns inside field values.

2. Step 2: Identify the operator for text pattern search

   $regex is the operator designed for regular expression matching in queries.

3. Final Answer:

   $regex -> Option B

4. Quick Check:

   Pattern matching = $regex [OK]

Hint: Use $regex to match text patterns in fields quickly [OK]

Common Mistakes:

• Confusing $regex with $match which filters documents
• Using $group which aggregates data, not filters by pattern
• Using $project which reshapes documents, not filters

2. Which MongoDB aggregation stage converts a document's fields into an array of key-value pairs, useful for filtering variable field names?

easy

A. $objectToArray

B. $filter

C. $arrayToObject

D. $match

Solution

1. Step 1: Understand field-to-array conversion

   $objectToArray converts document fields into an array of {k, v} pairs.

2. Step 2: Identify the correct stage for this conversion

   $objectToArray is the aggregation operator that does this transformation.

3. Final Answer:

   $objectToArray -> Option A

4. Quick Check:

   Field to array = $objectToArray [OK]

Hint: Use $objectToArray to turn fields into key-value arrays [OK]

Common Mistakes:

• Using $filter which filters arrays but doesn't convert fields
• Confusing $arrayToObject which does the reverse conversion
• Using $match which filters documents, not fields

3. Given this aggregation pipeline snippet, what will be the output for a document {"a1": 5, "b2": 10, "c3": 15}?

{
  $project: {
    filteredFields: {
      $filter: {
        input: { $objectToArray: "$ROOT" },
        as: "field",
        cond: { $regexMatch: { input: "$$field.k", regex: /^a/ } }
      }
    }
  }
}

medium

A. {"filteredFields": [{"k": "a1", "v": 5}]}

B. {"filteredFields": [{"k": "b2", "v": 10}]}

C. {"filteredFields": [{"k": "c3", "v": 15}]}

D. {"filteredFields": []}

Solution

1. Step 1: Convert document fields to array

   $objectToArray converts {"a1":5,"b2":10,"c3":15} to [{k:"a1",v:5},{k:"b2",v:10},{k:"c3",v:15}].

2. Step 2: Filter keys starting with 'a'

   $filter with regex /^a/ keeps only fields where key starts with 'a', so only {k:"a1",v:5} remains.

3. Final Answer:

   {"filteredFields": [{"k": "a1", "v": 5}]} -> Option A

4. Quick Check:

   Filter keys /^a/ = only "a1" field [OK]

Hint: Filter keys with $regexMatch inside $filter after $objectToArray [OK]

Common Mistakes:

• Forgetting to convert fields to array before filtering
• Using wrong regex pattern or syntax
• Expecting all fields instead of filtered ones

4. Identify the error in this aggregation stage that tries to filter fields with names containing 'score':

{
  $project: {
    scores: {
      $filter: {
        input: { $objectToArray: "$ROOT" },
        as: "field",
        cond: { $regex: "score", input: "$$field.k" }
      }
    }
  }
}

medium

A. Incorrect order of $regex arguments; 'input' must come first

B. Missing $match stage before $project

C. Using $regex instead of $regexMatch inside $filter condition

D. Cannot use $objectToArray on $ROOT

Solution

1. Step 1: Check $regex usage inside $filter cond

   $regex is a query operator, but inside aggregation expressions, $regexMatch must be used for regex matching.

2. Step 2: Identify correct regex function for aggregation

   Use $regexMatch with 'input' and 'regex' keys; $regex alone is invalid here.

3. Final Answer:

   Using $regex instead of $regexMatch inside $filter condition -> Option C

4. Quick Check:

   Aggregation regex = $regexMatch, not $regex [OK]

Hint: Use $regexMatch, not $regex, inside aggregation expressions [OK]

Common Mistakes:

• Swapping input and regex keys in $regexMatch
• Trying to use $regex query operator inside aggregation
• Assuming $objectToArray can't be used on $ROOT

5. You have documents with variable field names like "score_math", "score_science", "age", "name". How do you write an aggregation pipeline stage to create a new field "scores" containing only fields whose names start with "score_" and their values?

hard

A. { $project: { scores: { $objectToArray: "$ROOT" } } }

B. { $match: { scores: { $regex: /^score_/ } } }

C. { $project: { scores: { $filter: { input: "$ROOT", as: "f", cond: { $regexMatch: { input: "$$f.k", regex: /^score_/ } } } } } }

D. { $project: { scores: { $arrayToObject: { $filter: { input: { $objectToArray: "$ROOT" }, as: "f", cond: { $regexMatch: { input: "$$f.k", regex: /^score_/ } } } } } } }

Solution

1. Step 1: Convert document fields to array for filtering

   Use $objectToArray on "$ROOT" to get array of key-value pairs.

2. Step 2: Filter keys starting with "score_" using $filter and $regexMatch

   Apply $filter with condition $regexMatch on keys matching /^score_/.

3. Step 3: Convert filtered array back to object

   Use $arrayToObject to convert filtered array back to an object with only score fields.

4. Final Answer:

   { $project: { scores: { $arrayToObject: { $filter: { input: { $objectToArray: "$ROOT" }, as: "f", cond: { $regexMatch: { input: "$$f.k", regex: /^score_/ } } } } } } } -> Option D

5. Quick Check:

   Filter keys + convert back = { $project: { scores: { $arrayToObject: { $filter: { input: { $objectToArray: "$ROOT" }, as: "f", cond: { $regexMatch: { input: "$$f.k", regex: /^score_/ } } } } } } } [OK]

Hint: Convert fields to array, filter keys, then convert back to object [OK]

Common Mistakes:

• Trying to filter directly on $ROOT without conversion
• Using $match instead of $project for field transformation
• Not converting filtered array back to object with $arrayToObject