Attribute pattern for variable fields in MongoDB - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to find documents where the field name starts with 'user_'.

MongoDB

db.collection.find({ [1]: { $exists: true } })

Drag options to blanks, or click blank then click option'

A"user_*"

B"user_"

C/^user_/

Attempts:

3 left

💡 Hint

Common Mistakes

Using quotes without regex syntax.

Using wildcard characters like '*' inside quotes incorrectly.

The query uses a regular expression to match field names starting with 'user_'. The correct syntax is to use a regex pattern like /^user_/.

2fill in blank

medium

Complete the code to find documents where the field name starts with 'data_'.

MongoDB

db.collection.find({ [1]: { $exists: true } })

Drag options to blanks, or click blank then click option'

A"data_.*"

B/^data_/

C"data_*"

D"data_"

Attempts:

3 left

💡 Hint

Common Mistakes

Using wildcard '*' inside quotes without regex.

Using string patterns like 'data_.*' incorrectly.

The query uses a regular expression to match field names starting with 'data_'. The correct syntax is to use a regex pattern like /^data_/.

3fill in blank

hard

Fix the error in the query to find documents with any field starting with 'attr_'.

MongoDB

db.collection.find({ [1]: { $exists: true } })

Drag options to blanks, or click blank then click option'

A/^attr_/

B"attr_.*"

C"attr_"

D"attr_*"

Attempts:

3 left

💡 Hint

Common Mistakes

Using string patterns without regex.

Using incorrect regex syntax.

The query needs to use a regular expression to match any field name starting with 'attr_'. Using /^attr_/ as the key in the query is the correct approach.

4fill in blank

hard

Fill both blanks to create a query that finds documents where any field starting with 'meta_' has the value 'active'.

MongoDB

db.collection.find({ [1]: [2] })

Drag options to blanks, or click blank then click option'

A/^meta_/

B"active"

Ctrue

Attempts:

3 left

💡 Hint

Common Mistakes

Using string instead of regex for field names.

Using boolean true instead of string 'active'.

The query uses a regex /^meta_/ to match field names starting with 'meta_' and checks if their value is 'active'.

5fill in blank

hard

Fill all three blanks to create an aggregation pipeline that filters documents where the 'info_score' field has a numeric value greater than 10, and projects that field.

MongoDB

db.collection.aggregate([{ $match: { [1]: { $gt: [2] } } }, { $project: { [3]: 1 } }])

Drag options to blanks, or click blank then click option'

A"info_score"

B10

D"info_value"

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect field names.

Using string '10' instead of number 10.

The aggregation matches documents where 'info_score' is greater than 10 and projects the 'info_score' field.

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