Attribute pattern for variable fields in MongoDB - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an attribute pattern for variable fields in MongoDB?

It is a way to query documents where the field names can change or vary, using patterns like regular expressions to match those field names.

intermediate

How can you match documents with field names starting with 'item_' in MongoDB?

Use the $regex operator on the field names with the pattern /^item_/. This helps find fields whose names start with 'item_'.

beginner

Why do we need attribute patterns for variable fields in MongoDB?

Because MongoDB documents can have dynamic or varying field names, attribute patterns help us search or filter based on those changing field names.

beginner

Which MongoDB operator helps to filter documents by matching field names with a pattern?

The $regex operator is used to match strings, including field names, against a regular expression pattern.

advanced

Give an example of a MongoDB query to find documents where any field name contains 'score'.

Use an aggregation with $objectToArray to convert fields to key-value pairs, then filter keys with $regex: { $match: { $expr: { $gt: [ { $size: { $filter: { input: { $objectToArray: "$$ROOT" }, cond: { $regexMatch: { input: "$$this.k", regex: /score/ } } } } }, 0 ] } } }

Which MongoDB operator is used to match field names with a pattern?

A $match

B $project

C $group

D $regex

The $regex operator matches strings against a regular expression pattern, useful for matching field names.

What does $objectToArray do in MongoDB aggregation?

A Filters documents by array length

B Converts document fields into an array of key-value pairs

C Sorts documents by field values

D Updates array elements

$objectToArray converts the fields of a document into an array of {k, v} objects, allowing pattern matching on keys.

Why might you use attribute patterns in MongoDB?

A To query documents with dynamic or varying field names

B To update all documents at once

C To create indexes on fixed fields

D To delete documents by ID

Attribute patterns help find documents where field names change or vary, which is common in MongoDB.

Which of these is a valid regex pattern to match fields starting with 'user_'?

A /user/

B /user$/

C /^user_/

D /^_user/

/^user_/ matches strings that start with 'user_'.

In MongoDB, how do you check if any field name contains 'price' using aggregation?

A Use $objectToArray and $filter with $regexMatch on keys

B Use $match with $exists

C Use $group by field names

D Use $project to rename fields

Converting fields to array and filtering keys with regex helps find fields containing 'price'.

Explain how to query MongoDB documents when field names vary and you want to find fields matching a pattern.

Think about turning fields into an array to work with their names.

Describe why attribute patterns are useful in MongoDB and give an example scenario.

Consider when field names are not fixed but follow a naming style.

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