$group stage for aggregation in MongoDB - Step-by-Step Execution

Concept Flow - $group stage for aggregation

Input Documents

↓

Apply $group Stage

↓

Group by _id Key

↓

Aggregate Fields (sum, avg, etc.)

↓

Output Grouped Documents

The $group stage collects input documents, groups them by a specified key (_id), and computes aggregate values for each group.

Execution Sample

MongoDB

db.sales.aggregate([
  { $group: { _id: "$item", totalQty: { $sum: "$quantity" } } }
])

Groups sales documents by item and sums the quantity for each item.

Execution Table

Step	Input Document	Group Key (_id)	Aggregation Action	Group State After Step
1	{ item: "apple", quantity: 5 }	"apple"	Create group 'apple', sum=5	{ apple: 5 }
2	{ item: "banana", quantity: 3 }	"banana"	Create group 'banana', sum=3	{ apple: 5, banana: 3 }
3	{ item: "apple", quantity: 2 }	"apple"	Add 2 to sum of 'apple'	{ apple: 7, banana: 3 }
4	{ item: "banana", quantity: 4 }	"banana"	Add 4 to sum of 'banana'	{ apple: 7, banana: 7 }
5	{ item: "orange", quantity: 1 }	"orange"	Create group 'orange', sum=1	{ apple: 7, banana: 7, orange: 1 }
6	No more documents	N/A	Aggregation complete	{ apple: 7, banana: 7, orange: 1 }

💡 All input documents processed; aggregation groups finalized.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	Final
Group 'apple' sum	0	5	5	7	7	7	7
Group 'banana' sum	0	0	3	3	7	7	7
Group 'orange' sum	0	0	0	0	0	1	1

Key Moments - 3 Insights

Why does the $group stage use _id as the grouping key?

The _id field defines how documents are grouped. Each unique _id value creates a separate group. This is shown in the execution_table where each input document's item field becomes the _id key.

What happens when a new group key appears in the input documents?

A new group is created with initial aggregation values. For example, when 'orange' appears at step 5, a new group is created with sum starting at the quantity of that document.

How does the aggregation update existing groups?

When a document's group key matches an existing group, aggregation operators like $sum add to the current total. See step 3 where 'apple' sum increases from 5 to 7.

Visual Quiz - 3 Questions

Look at the execution_table, what is the sum for group 'banana' after step 4?

A 7

B 3

C 4

D 0

💡 Hint

Check the 'Group State After Step' column at step 4 for 'banana'.

At which step does the group 'orange' get created?

A Step 2

B Step 3

C Step 5

D Step 6

💡 Hint

Look for when 'orange' first appears in the 'Group Key (_id)' column.

If the third document had quantity 4 instead of 2, what would be the final sum for 'apple'?

A 7

B 9

C 11

D 5

💡 Hint

Add the changed quantity to the previous sum for 'apple' from the variable_tracker.

Concept Snapshot

$group stage syntax:
{ $group: { _id: <grouping_key>, <field>: { <accumulator>: <expression> } } }
Groups documents by _id and applies accumulators like $sum, $avg.
Each unique _id value creates one output document.
Useful for summarizing data by categories.

Full Transcript

The $group stage in MongoDB aggregation groups input documents by a specified key called _id. Each unique _id value forms a group. For each group, accumulator operators like $sum add values from documents in that group. The execution table shows step-by-step how documents are processed: new groups are created when a new _id appears, and existing groups update their totals. Variables track sums for each group after each step. Key moments clarify why _id is used, how new groups form, and how aggregation updates work. The visual quiz tests understanding of sums at steps, group creation timing, and effects of changing input values. The snapshot summarizes syntax and behavior for quick reference.

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