Attribute pattern for variable fields in MongoDB - Mini Project: Build & Apply

Attribute Pattern for Variable Fields in MongoDB

📖 Scenario: You are managing a MongoDB collection for a small online store. Each product can have different attributes depending on its category. For example, electronics have brand and warranty, while clothing has size and material. You want to store these variable fields efficiently and query them.

🎯 Goal: Build a MongoDB document structure that uses an attribute pattern to store variable fields for different product categories. Then write a query to find products with a specific attribute.

📋 What You'll Learn

Create a MongoDB collection named products with documents having fixed fields _id, name, and category.

Add a variable attributes field as a sub-document to store category-specific attributes.

Write a query to find all products where the attributes contain a specific key-value pair.

💡 Why This Matters

🌍 Real World

Many real-world databases store items with different attributes depending on their type. Using an attribute pattern helps keep the data flexible and easy to query.

💼 Career

Understanding how to model variable fields and query them is important for database developers and data engineers working with NoSQL databases like MongoDB.

1

Create the products collection with sample documents

Create a variable called products that is a list of three MongoDB documents. Each document must have the fields _id, name, and category with these exact values: {'_id': 1, 'name': 'Smartphone', 'category': 'Electronics'}, {'_id': 2, 'name': 'T-Shirt', 'category': 'Clothing'}, and {'_id': 3, 'name': 'Laptop', 'category': 'Electronics'}.

MongoDB

# Create the products list with three documents
# Your code here

Hint

Use a Python list with dictionaries for each product document.

2

Add the attributes field with variable data

Add an attributes field to each document in the products list. For the product with _id 1, add {'brand': 'BrandX', 'warranty': '2 years'}. For _id 2, add {'size': 'M', 'material': 'Cotton'}. For _id 3, add {'brand': 'BrandY', 'warranty': '1 year'}.

MongoDB

products = [
    {'_id': 1, 'name': 'Smartphone', 'category': 'Electronics'},
    {'_id': 2, 'name': 'T-Shirt', 'category': 'Clothing'},
    {'_id': 3, 'name': 'Laptop', 'category': 'Electronics'}
]
# Add the attributes field to each product below
# Your code here

Hint

Add the attributes key with a dictionary value inside each product dictionary.

3

Write a MongoDB query to find products with a specific attribute

Create a variable called query that is a MongoDB query document to find all products where the attributes.brand is exactly 'BrandX'.

MongoDB

products = [
    {'_id': 1, 'name': 'Smartphone', 'category': 'Electronics', 'attributes': {'brand': 'BrandX', 'warranty': '2 years'}},
    {'_id': 2, 'name': 'T-Shirt', 'category': 'Clothing', 'attributes': {'size': 'M', 'material': 'Cotton'}},
    {'_id': 3, 'name': 'Laptop', 'category': 'Electronics', 'attributes': {'brand': 'BrandY', 'warranty': '1 year'}}
]
# Create a query to find products with attributes.brand equal to 'BrandX'
# Your code here

Hint

Use dot notation in the query key to access nested fields.

4

Complete the MongoDB find operation using the query

Create a variable called result that simulates the MongoDB find operation by filtering the products list using the query. Use a list comprehension to include only products where attributes.brand equals 'BrandX'.

MongoDB

products = [
    {'_id': 1, 'name': 'Smartphone', 'category': 'Electronics', 'attributes': {'brand': 'BrandX', 'warranty': '2 years'}},
    {'_id': 2, 'name': 'T-Shirt', 'category': 'Clothing', 'attributes': {'size': 'M', 'material': 'Cotton'}},
    {'_id': 3, 'name': 'Laptop', 'category': 'Electronics', 'attributes': {'brand': 'BrandY', 'warranty': '1 year'}}
]
query = {'attributes.brand': 'BrandX'}
# Filter products using the query and assign to result
# Your code here

Hint

Use a list comprehension and dict.get() to safely access nested keys.

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