$group stage for aggregation in MongoDB - Mini Project: Build & Apply

$group Stage for Aggregation in MongoDB

📖 Scenario: You work at a bookstore that keeps sales records in a MongoDB collection. Each sale document records the bookTitle, author, and copiesSold. You want to find out how many copies of each book were sold in total.

🎯 Goal: Build a MongoDB aggregation pipeline using the $group stage to calculate the total copies sold for each book.

📋 What You'll Learn

Create a collection named sales with documents containing bookTitle, author, and copiesSold fields.

Define a variable pipeline that holds the aggregation stages.

Use the $group stage to group documents by bookTitle and calculate the total copiesSold for each book.

Add a final stage to sort the results by total copies sold in descending order.

💡 Why This Matters

🌍 Real World

Bookstores and many businesses use MongoDB aggregation pipelines to analyze sales data and generate reports.

💼 Career

Understanding the <code>$group</code> stage is essential for data analysts and backend developers working with MongoDB to summarize and aggregate data efficiently.

1

Create the sales data collection

Create a variable called sales that is a list of documents with these exact entries: { bookTitle: "The Hobbit", author: "J.R.R. Tolkien", copiesSold: 5 }, { bookTitle: "1984", author: "George Orwell", copiesSold: 8 }, { bookTitle: "The Hobbit", author: "J.R.R. Tolkien", copiesSold: 3 }, { bookTitle: "Dune", author: "Frank Herbert", copiesSold: 7 }.

MongoDB

# Create the sales data list with exact documents
# Your code here

Hint

Use a list of dictionaries with the exact keys and values as shown.

2

Define the aggregation pipeline variable

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

MongoDB

sales = [
    { "bookTitle": "The Hobbit", "author": "J.R.R. Tolkien", "copiesSold": 5 },
    { "bookTitle": "1984", "author": "George Orwell", "copiesSold": 8 },
    { "bookTitle": "The Hobbit", "author": "J.R.R. Tolkien", "copiesSold": 3 },
    { "bookTitle": "Dune", "author": "Frank Herbert", "copiesSold": 7 }
]
# Create an empty list called pipeline
# Your code here

Hint

Just create an empty list named pipeline.

3

Add the $group stage to sum copies sold by bookTitle

Add a $group stage to the pipeline list. Group by _id set to $bookTitle and create a field totalCopies that sums copiesSold.

MongoDB

sales = [
    { "bookTitle": "The Hobbit", "author": "J.R.R. Tolkien", "copiesSold": 5 },
    { "bookTitle": "1984", "author": "George Orwell", "copiesSold": 8 },
    { "bookTitle": "The Hobbit", "author": "J.R.R. Tolkien", "copiesSold": 3 },
    { "bookTitle": "Dune", "author": "Frank Herbert", "copiesSold": 7 }
]
pipeline = []
# Add a $group stage to pipeline to group by bookTitle and sum copiesSold
# Your code here

Hint

Use { "$group": { "_id": "$bookTitle", "totalCopies": { "$sum": "$copiesSold" } } } inside the pipeline list.

4

Add a $sort stage to order results by totalCopies descending

Add a $sort stage to the pipeline list that sorts by totalCopies in descending order (-1).

MongoDB

sales = [
    { "bookTitle": "The Hobbit", "author": "J.R.R. Tolkien", "copiesSold": 5 },
    { "bookTitle": "1984", "author": "George Orwell", "copiesSold": 8 },
    { "bookTitle": "The Hobbit", "author": "J.R.R. Tolkien", "copiesSold": 3 },
    { "bookTitle": "Dune", "author": "Frank Herbert", "copiesSold": 7 }
]
pipeline = [
    {
        "$group": {
            "_id": "$bookTitle",
            "totalCopies": { "$sum": "$copiesSold" }
        }
    }
]
# Add a $sort stage to pipeline to sort by totalCopies descending
# Your code here

Hint

Add { "$sort": { "totalCopies": -1 } } as the last stage in the pipeline list.

Practice

1. What is the main purpose of the $group stage in a MongoDB aggregation pipeline?

easy

A. To project specific fields from documents

B. To filter documents based on a condition

C. To sort documents in ascending or descending order

D. To group documents by a specified key and perform calculations on each group

Solution

1. Step 1: Understand the role of $group

   The $group stage collects documents into groups based on a key defined in the _id field.

2. Step 2: Identify what $group does with groups

   It allows performing calculations like sum, count, or average on each group.

3. Final Answer:

   To group documents by a specified key and perform calculations on each group -> Option D

4. Quick Check:

   $group groups and calculates [OK]

Hint: Remember: $group always groups and aggregates [OK]

Common Mistakes:

• Confusing $group with $match for filtering
• Thinking $group sorts documents
• Assuming $group projects fields without grouping

2. Which of the following is the correct syntax to group documents by the field category and count the number of documents in each group?

easy

A. { $group: { category: "$category", count: { $sum: 1 } } }

B. { $group: { _id: "$category", count: { $sum: 1 } } }

C. { $group: { _id: "$category", count: { $count: 1 } } }

D. { $group: { _id: "$category", count: { $add: 1 } } }

Solution

1. Step 1: Identify the grouping key field

   The grouping key must be assigned to _id, so _id: "$category" is correct.

2. Step 2: Use the correct accumulator for counting

   Counting documents uses $sum: 1 to add 1 for each document in the group.

3. Final Answer:

   { $group: { _id: "$category", count: { $sum: 1 } } } -> Option B

4. Quick Check:

   Group key in _id and count with $sum: 1 [OK]

Hint: Always use _id for group key and $sum: 1 to count [OK]

Common Mistakes:

• Using field name instead of _id for grouping key
• Using $count instead of $sum for counting
• Using $add which is not an accumulator

3. Given the collection documents:

{ "category": "A", "value": 10 }

{ "category": "B", "value": 20 }

{ "category": "A", "value": 15 }

What will be the output of this aggregation?

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

medium

A. [{ "_id": "A", "total": 25 }, { "_id": "B", "total": 20 }]

B. [{ "_id": "A", "total": 10 }, { "_id": "B", "total": 20 }, { "_id": "A", "total": 15 }]

C. [{ "_id": "A", "total": 15 }, { "_id": "B", "total": 20 }]

D. [{ "_id": null, "total": 45 }]

Solution

1. Step 1: Group documents by category

   Documents with category "A" are grouped together, and category "B" separately.

2. Step 2: Sum the value fields in each group

   For category "A": 10 + 15 = 25; for category "B": 20.

3. Final Answer:

   [{ "_id": "A", "total": 25 }, { "_id": "B", "total": 20 }] -> Option A

4. Quick Check:

   Sum values per category = correct totals [OK]

Hint: Sum values grouped by _id key field [OK]

Common Mistakes:

• Expecting separate documents without grouping
• Summing incorrectly or ignoring grouping
• Using _id: null which groups all documents together

4. Identify the error in this aggregation pipeline stage:

{ $group: { category: "$category", total: { $sum: "$amount" } } }

medium

A. Field names should not be in quotes

B. Incorrect use of $sum operator

C. Missing _id field for grouping key

D. Aggregation pipeline stage must be an array

Solution

1. Step 1: Check for required _id field in $group

   The _id field is mandatory to specify the grouping key.

2. Step 2: Verify other syntax elements

   The $sum operator and field references are correct; only _id is missing.

3. Final Answer:

   Missing _id field for grouping key -> Option C

4. Quick Check:

   _id is required in $group [OK]

Hint: Always include _id in $group stage [OK]

Common Mistakes:

• Omitting the _id field
• Confusing field names with grouping key
• Thinking $sum needs special syntax

5. You have a collection of sales documents with fields store, item, and quantity. You want to find the total quantity sold per store, but only for stores where the total quantity exceeds 100. Which aggregation pipeline correctly achieves this?

hard

A. [{ $group: { _id: "$store", totalQuantity: { $sum: "$quantity" } } }, { $match: { totalQuantity: { $gt: 100 } } }]

B. [{ $match: { quantity: { $gt: 100 } } }, { $group: { _id: "$store", totalQuantity: { $sum: "$quantity" } } }]

C. [{ $group: { _id: "$store", totalQuantity: { $sum: "$quantity" } } }, { $match: { _id: { $gt: 100 } } }]

D. [{ $group: { _id: "$store", totalQuantity: { $sum: "$quantity" } } }, { $sort: { totalQuantity: -1 } }]

Solution

1. Step 1: Group by store and sum quantity

   The $group stage groups documents by store and calculates total quantity sold per store.

2. Step 2: Filter groups where total quantity > 100

   The $match stage after grouping filters groups with totalQuantity greater than 100.

3. Final Answer:

   [{ $group: { _id: "$store", totalQuantity: { $sum: "$quantity" } } }, { $match: { totalQuantity: { $gt: 100 } } }] -> Option A

4. Quick Check:

   Group then filter by aggregated field [OK]

Hint: Filter after grouping using $match on aggregated fields [OK]

Common Mistakes:

• Filtering before grouping which filters documents, not groups
• Filtering on _id instead of aggregated field
• Using $sort instead of filtering