Why aggregation operators matter in MongoDB - See It in Action

Why aggregation operators matter

📖 Scenario: You work at a small bookstore that keeps track of sales in a MongoDB database. You want to learn how to use aggregation operators to find useful information like total sales and average price per book.

🎯 Goal: Build a MongoDB aggregation pipeline step-by-step to calculate the total number of books sold and the average price of books sold.

📋 What You'll Learn

Create a collection called sales with documents containing book, price, and quantity fields.

Add a variable to hold the aggregation pipeline stages.

Use the $group aggregation operator to calculate total quantity sold and average price.

Complete the aggregation pipeline and assign it to a variable.

💡 Why This Matters

🌍 Real World

Aggregation operators help summarize and analyze data in databases, like calculating total sales or average prices in a bookstore.

💼 Career

Database developers and analysts use aggregation pipelines to generate reports and insights from large data collections efficiently.

1

DATA SETUP: Create the sales collection with sample documents

Create a variable called sales that is a list of three documents with these exact entries: { book: "MongoDB Basics", price: 20, quantity: 5 }, { book: "Advanced MongoDB", price: 35, quantity: 3 }, and { book: "MongoDB Aggregation", price: 25, quantity: 7 }.

MongoDB

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

Hint

Use a Python list of dictionaries to represent the sales documents.

2

CONFIGURATION: Define the aggregation pipeline variable

Create a variable called pipeline and set it to an empty list [] to hold the aggregation stages.

MongoDB

sales = [
    {"book": "MongoDB Basics", "price": 20, "quantity": 5},
    {"book": "Advanced MongoDB", "price": 35, "quantity": 3},
    {"book": "MongoDB Aggregation", "price": 25, "quantity": 7}
]
# Create an empty pipeline list
# Your code here

Hint

Just create an empty list called pipeline.

3

CORE LOGIC: Add a $group stage to calculate total quantity and average price

Add a dictionary to the pipeline list with a $group stage that groups all documents together (_id: null) and calculates totalQuantity as the sum of quantity and averagePrice as the average of price.

MongoDB

sales = [
    {"book": "MongoDB Basics", "price": 20, "quantity": 5},
    {"book": "Advanced MongoDB", "price": 35, "quantity": 3},
    {"book": "MongoDB Aggregation", "price": 25, "quantity": 7}
]
pipeline = []
# Add a $group stage to pipeline
# Your code here

Hint

Use $group with _id: null to aggregate all documents together.

4

COMPLETION: Assign the aggregation pipeline to a variable called aggregation_pipeline

Create a variable called aggregation_pipeline and assign it the value of the pipeline list.

MongoDB

sales = [
    {"book": "MongoDB Basics", "price": 20, "quantity": 5},
    {"book": "Advanced MongoDB", "price": 35, "quantity": 3},
    {"book": "MongoDB Aggregation", "price": 25, "quantity": 7}
]
pipeline = [
    {
        "$group": {
            "_id": null,
            "totalQuantity": {"$sum": "$quantity"},
            "averagePrice": {"$avg": "$price"}
        }
    }
]
# Assign pipeline to aggregation_pipeline
# Your code here

Hint

Just assign the existing pipeline list to aggregation_pipeline.

Practice

1. What is the main purpose of aggregation operators in MongoDB?

easy

A. To summarize and analyze data quickly

B. To insert new documents into a collection

C. To delete documents from a collection

D. To create indexes on collections

Solution

1. Step 1: Understand aggregation operators

   Aggregation operators are used to process data and return computed results like sums, averages, and counts.

2. Step 2: Compare with other operations

   Inserting, deleting, and indexing are different operations unrelated to aggregation.

3. Final Answer:

   To summarize and analyze data quickly -> Option A

4. Quick Check:

   Aggregation = Summarize data [OK]

Hint: Aggregation operators summarize data fast [OK]

Common Mistakes:

• Confusing aggregation with data insertion
• Thinking aggregation deletes data
• Mixing aggregation with indexing

2. Which of the following is the correct syntax to use the $sum aggregation operator in a MongoDB pipeline?

easy

A. { $group: { _id: "$amount", total: $sum } }

B. { $sum: { $group: { total: "$amount" } } }

C. { $group: { _id: null, total: { $sum: "$amount" } } }

D. { $group: { total: { sum: "$amount" } } }

Solution

1. Step 1: Review $group stage syntax

   The $group stage groups documents and applies accumulators like $sum to fields.

2. Step 2: Check correct $sum usage

   $sum must be inside $group with a field path as "$fieldName" and an _id for grouping.

3. Final Answer:

   { $group: { _id: null, total: { $sum: "$amount" } } } -> Option C

4. Quick Check:

   $sum inside $group with field path [OK]

Hint: Use $sum inside $group with field path in quotes [OK]

Common Mistakes:

• Placing $sum outside $group
• Missing quotes around field name
• Incorrect _id usage in $group

3. Given the collection documents: [{"category": "A", "value": 10}, {"category": "A", "value": 20}, {"category": "B", "value": 5}], what will be the output of this aggregation pipeline?

[{ $group: { _id: "$category", totalValue: { $sum: "$value" } } }]

medium

A. [{ "_id": "A", "totalValue": 10 }, { "_id": "B", "totalValue": 5 }]

B. [{ "_id": "A", "totalValue": 30 }, { "_id": "B", "totalValue": 5 }]

C. [{ "_id": null, "totalValue": 35 }]

D. [{ "_id": "A", "totalValue": 20 }, { "_id": "B", "totalValue": 5 }]

Solution

1. Step 1: Group documents by category

   The $group stage groups documents by the "category" field, so we get groups for "A" and "B".

2. Step 2: Sum the "value" fields per group

   For category "A", sum is 10 + 20 = 30; for "B", sum is 5.

3. Final Answer:

   [{ "_id": "A", "totalValue": 30 }, { "_id": "B", "totalValue": 5 }] -> Option B

4. Quick Check:

   Sum values grouped by category [OK]

Hint: Sum values grouped by _id field [OK]

Common Mistakes:

• Forgetting to group by category
• Summing all values without grouping
• Using null as _id incorrectly

4. Identify the error in this aggregation pipeline:

[{ $group: { _id: "$category", total: { $sum: value } } }]

medium

A. Missing quotes around the field name "value" inside $sum

B. Using $sum inside $group is not allowed

C. The _id field cannot be "$category"

D. The pipeline must start with $match stage

Solution

1. Step 1: Check $sum syntax

   The field name inside $sum must be a string with quotes, like "$value".

2. Step 2: Validate other parts

   Using $sum inside $group and _id as "$category" are correct; $match is optional.

3. Final Answer:

   Missing quotes around the field name "value" inside $sum -> Option A

4. Quick Check:

   Field names in $sum need quotes [OK]

Hint: Always quote field names in aggregation operators [OK]

Common Mistakes:

• Omitting quotes around field names
• Thinking $sum can't be used in $group
• Assuming $match is mandatory first stage

5. You want to find the average "score" for each "team" but only for scores greater than 50. Which aggregation pipeline correctly achieves this?

hard

A. [{ $match: { team: { $gt: 50 } } }, { $group: { _id: "$team", avgScore: { $avg: "$score" } } }]

B. [{ $group: { _id: "$team", avgScore: { $avg: { $gt: ["$score", 50] } } } }]

C. [{ $group: { _id: "$team", avgScore: { $avg: "$score" } } }, { $match: { avgScore: { $gt: 50 } } }]

D. [{ $match: { score: { $gt: 50 } } }, { $group: { _id: "$team", avgScore: { $avg: "$score" } } }]

Solution

1. Step 1: Filter scores greater than 50

   The $match stage filters documents where "score" is greater than 50 before grouping.

2. Step 2: Group by "team" and calculate average

   The $group stage groups by "team" and calculates average "score" using $avg.

3. Step 3: Verify other options

   [{ $group: { _id: "$team", avgScore: { $avg: { $gt: ["$score", 50] } } } }] misuses $avg with $gt; [{ $group: { _id: "$team", avgScore: { $avg: "$score" } } }, { $match: { avgScore: { $gt: 50 } } }] filters after averaging, which is incorrect; [{ $match: { team: { $gt: 50 } } }, { $group: { _id: "$team", avgScore: { $avg: "$score" } } }] filters on "team" field incorrectly.

4. Final Answer:

   [{ $match: { score: { $gt: 50 } } }, { $group: { _id: "$team", avgScore: { $avg: "$score" } } }] -> Option D

5. Quick Check:

   Filter first, then group and average [OK]

Hint: Filter with $match before grouping for correct averages [OK]

Common Mistakes:

• Filtering after grouping instead of before
• Misusing $avg with conditions inside
• Filtering wrong fields in $match