$count accumulator in MongoDB - Step-by-Step Execution

Concept Flow - $count accumulator

Start Aggregation Pipeline

↓

Process Each Document

↓

$count Accumulator Increments

↓

Output Total Count

↓

End

The $count accumulator counts each document passing through the pipeline and outputs the total count at the end.

Execution Sample

MongoDB

db.collection.aggregate([
  { $group: { _id: null, total: { $sum: 1 } } }
])

Counts all documents in the collection and outputs the total count as 'total'.

Execution Table

Step	Document Processed	$count Value	Action	Output
1	{_id: 1, name: 'Alice'}	1	Increment count by 1	No output yet
2	{_id: 2, name: 'Bob'}	2	Increment count by 1	No output yet
3	{_id: 3, name: 'Charlie'}	3	Increment count by 1	No output yet
4	No more documents	3	Output total count	{_id: null, total: 3}

💡 All documents processed, $count outputs the total count 3.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
$count	0	1	2	3	3

Key Moments - 2 Insights

Why does $count output only once at the end instead of after each document?

$count accumulates the count internally as documents pass through. It outputs only once after processing all documents, as shown in execution_table row 4.

Can $count be used without $group stage?

$count is an accumulator and must be used inside a $group stage, as in the example code. It cannot be used alone.

Visual Quiz - 3 Questions

Look at the execution table, what is the $count value after processing the second document?

A 1

B 3

C 2

D 0

💡 Hint

Check the $count Value column at Step 2 in the execution_table.

At which step does the $count accumulator output the total count?

A Step 4

B Step 1

C Step 3

D Step 2

💡 Hint

Look for the step where 'Output total count' action happens in the execution_table.

If the collection had 5 documents instead of 3, what would be the final $count value?

A 4

B 5

C 3

D 6

💡 Hint

Refer to variable_tracker showing $count increments per document.

Concept Snapshot

$count accumulator counts documents in a $group stage.
Syntax: { $group: { _id: null, total: { $sum: 1 } } }
Counts each document passing through.
Outputs total count once after all documents.
Must be used inside $group stage.

Full Transcript

The $count accumulator in MongoDB aggregation counts how many documents pass through the pipeline. It is used inside a $group stage to accumulate a total count. As each document is processed, $count increments by one. It does not output intermediate counts but only outputs the final total count after all documents are processed. For example, if there are three documents, $count increments from 0 to 3, then outputs {total: 3}. This accumulator is useful to find the number of documents matching certain criteria in aggregation pipelines.

Practice

1. What does the $count accumulator do in a MongoDB aggregation pipeline?

easy

A. Counts the number of documents in each group

B. Sums the values of a field in each group

C. Finds the maximum value in each group

D. Calculates the average of a field in each group

Solution

1. Step 1: Understand the purpose of $count

   The $count accumulator is used inside the $group stage to count how many documents belong to each group.

2. Step 2: Compare with other accumulators

   Unlike $sum, $max, or $avg, $count does not operate on field values but counts documents.

3. Final Answer:

   Counts the number of documents in each group -> Option A

4. Quick Check:

   $count = document count [OK]

Hint: Remember: $count counts documents, no field needed [OK]

Common Mistakes:

• Thinking $count sums field values
• Using $count outside $group stage
• Expecting $count to take arguments

2. Which of the following is the correct syntax to count documents per category using $count in a $group stage?

easy

A. { $group: { _id: "$category", total: { $count: "$price" } } }

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

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

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

Solution

1. Step 1: Recall $count syntax

   The $count accumulator does not take any arguments inside its braces; it should be empty: { $count: {} }.

2. Step 2: Check each option

   Options A, B, and D incorrectly pass a field name or string to $count, which is invalid syntax.

3. Final Answer:

   { $group: { _id: "$category", total: { $count: {} } } } -> Option D

4. Quick Check:

   Empty braces for $count = correct syntax [OK]

Hint: Use empty braces {} inside $count always [OK]

Common Mistakes:

• Passing a field name inside $count
• Using empty string instead of empty braces
• Confusing $count with $sum syntax

3. Given the collection documents:

{ "category": "A" }, { "category": "B" }, { "category": "A" }

What will be the output of this aggregation?

[ { $group: { _id: "$category", count: { $count: {} } } } ]

medium

A. SyntaxError: $count requires a field name

B. [ { "_id": "A", "count": 1 }, { "_id": "B", "count": 2 } ]

C. [ { "_id": "A", "count": 3 }, { "_id": "B", "count": 3 } ]

D. [ { "_id": "A", "count": 2 }, { "_id": "B", "count": 1 } ]

Solution

1. Step 1: Understand $count usage

   The $count accumulator is not valid inside a $group stage. It is a separate pipeline stage used to count total documents, not per group.

2. Step 2: Correct way to count documents per group

   To count documents per group, use $sum: 1 inside $group, not $count.

3. Step 3: Result of using $count inside $group

   Using $count inside $group causes a syntax error.

4. Final Answer:

   SyntaxError: $count requires a field name -> Option A

5. Quick Check:

   $count is a pipeline stage, not an accumulator [OK]

Hint: Use $sum: 1 to count documents per group, not $count [OK]

Common Mistakes:

• Using $count inside $group
• Expecting $count to count per group
• Confusing $count accumulator with $count stage

4. Identify the error in this aggregation pipeline:

[ { $group: { _id: "$type", total: { $count: "$amount" } } } ]

medium

A. Missing $match stage before $group

B. Incorrect _id field name

C. Using $count with a field argument is invalid

D. Using $count outside aggregation pipeline

Solution

1. Step 1: Check $count usage

   The $count accumulator does not accept any arguments; passing "$amount" is invalid syntax.

2. Step 2: Verify other parts

   The _id field and pipeline structure are correct; no $match is required before $group, and $count is inside aggregation.

3. Final Answer:

   Using $count with a field argument is invalid -> Option C

4. Quick Check:

   $count must have empty braces {} [OK]

Hint: Never pass a field to $count, use empty braces {} [OK]

Common Mistakes:

• Passing a field name to $count
• Thinking $count needs $match before $group
• Confusing $count with $sum

5. You want to find how many orders each customer placed, but only for customers with more than 2 orders. Which aggregation pipeline correctly uses $count to achieve this?

hard

A. [ { $match: { orders: { $gt: 2 } } }, { $group: { _id: "$customer", orderCount: { $count: {} } } } ]

B. [ { $group: { _id: "$customer", orderCount: { $sum: 1 } } }, { $match: { orderCount: { $gt: 2 } } } ]

C. [ { $group: { _id: "$customer", orderCount: { $count: "$customer" } } }, { $match: { orderCount: { $gt: 2 } } } ]

D. [ { $group: { _id: "$customer", orderCount: { $count: {} } } }, { $match: { orderCount: { $gt: 2 } } } ]

Solution

1. Step 1: Count orders per customer

   Since $count is not valid inside $group, use $sum: 1 to count documents per group.

2. Step 2: Filter customers with more than 2 orders

   Use $match after grouping to filter customers with orderCount greater than 2.

3. Final Answer:

   [ { $group: { _id: "$customer", orderCount: { $sum: 1 } } }, { $match: { orderCount: { $gt: 2 } } } ] -> Option B

4. Quick Check:

   Use $sum:1 to count per group, then filter [OK]

Hint: Use $sum: 1 inside $group to count documents, then filter with $match [OK]

Common Mistakes:

• Using $count inside $group
• Passing a field to $count
• Filtering before counting