$count accumulator in MongoDB - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the $count accumulator do in MongoDB aggregation?

The $count accumulator counts the number of documents that pass through the aggregation pipeline stage and returns that count as a single number.

beginner

How do you use $count in a MongoDB aggregation pipeline?

You use $count inside a $group stage to count documents. For example: { $group: { _id: null, total: { $sum: 1 } } } counts all documents.

intermediate

Can $count be used without a $group stage in MongoDB?

No, $count is an accumulator and must be used inside a $group stage to count documents. To count documents without grouping, use the $count stage instead.

intermediate

What is the difference between the $count accumulator and the $count stage in MongoDB?

The $count accumulator is used inside $group to count documents per group. The $count stage counts all documents passing through and outputs a document with the count.

beginner

Write a simple MongoDB aggregation query using $count accumulator to count all documents.

db.collection.aggregate([{ $group: { _id: null, total: { $sum: 1 } } }])
This groups all documents together and counts them in the field total.

Where is the $count accumulator used in MongoDB?

A Inside a <code>$group</code> stage

B As a standalone aggregation stage

C Inside a <code>$match</code> stage

D Inside a <code>$project</code> stage

$count accumulator is used inside $group to count documents per group.

What does { $count: {} } do inside a $group stage?

A Counts the number of documents in the group

B Counts the number of fields in each document

C Counts the number of groups

D Filters documents

{ $count: {} } counts how many documents are in each group.

Which of these is a correct way to count all documents in a collection using aggregation?

A Both A and B

B Neither A nor B

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

D db.collection.aggregate([{ $count: 'total' }])

The correct way is using the $count stage: db.collection.aggregate([{ $count: 'total' }]). The $count accumulator does not exist; use $sum: 1 inside $group instead.

Can $count accumulator count documents without grouping?

A Yes, it works alone

B No, it requires a <code>$group</code> stage

C Yes, inside <code>$match</code>

D No, it only counts fields

$count accumulator must be inside $group to work.

What will this aggregation return? [{ $group: { _id: "$category", count: { $count: {} } } }]

A List of categories without counts

B Total count of all documents

C Error because <code>$count</code> is invalid

D Count of documents per category

It will cause an error because $count is not a valid accumulator. Use $sum: 1 to count documents per group.

Explain how the $count accumulator works in a MongoDB aggregation pipeline.

Think about grouping documents and counting them.

Describe the difference between the $count accumulator and the $count stage in MongoDB.

One is inside grouping, the other is a separate pipeline step.

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