$count accumulator in MongoDB - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to count all documents in the collection.

MongoDB

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

Drag options to blanks, or click blank then click option'

A$count

B$sum

C$avg

D$max

Attempts:

3 left

💡 Hint

Common Mistakes

Using $sum instead of $count to count documents.

Using $avg or $max which do not count documents.

The $count accumulator counts the number of documents in the group.

2fill in blank

medium

Complete the code to count documents grouped by category.

MongoDB

db.collection.aggregate([{ $group: { _id: "$category", count: { [1]: {} } } }])

Drag options to blanks, or click blank then click option'

A$count

B$sum

C$min

D$max

Attempts:

3 left

💡 Hint

Common Mistakes

Using $sum: 1 instead of $count.

Using $min or $max which do not count documents.

Use $count to count documents per group by category.

3fill in blank

hard

Fix the error in the aggregation to count documents by status.

MongoDB

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

Drag options to blanks, or click blank then click option'

A$avg

B$sum

C$count

D$max

Attempts:

3 left

💡 Hint

Common Mistakes

Using $sum: 1 instead of $count: {}.

Passing a value to $count which expects an empty object.

The $count accumulator does not take a value; $sum: 1 counts documents but $count is the correct accumulator here.

4fill in blank

hard

Fill both blanks to count documents grouped by type and filter groups with count greater than 5.

MongoDB

db.collection.aggregate([
  { $group: { _id: "$type", count: { [1]: {} } } },
  { $match: { count: { [2]: 5 } } }
])

Drag options to blanks, or click blank then click option'

A$count

B$gt

C$gte

D$sum

Attempts:

3 left

💡 Hint

Common Mistakes

Using $sum instead of $count in $group.

Using $gte instead of $gt for filtering.

Use $count to count documents per type and $gt to filter counts greater than 5.

5fill in blank

hard

Fill all three blanks to count documents by category, filter counts greater than 10, and sort descending by count.

MongoDB

db.collection.aggregate([
  { $group: { _id: [1], count: { [2]: {} } } },
  { $match: { count: { [3]: 10 } } },
  { $sort: { count: -1 } }
])

Drag options to blanks, or click blank then click option'

A"$category"

B$count

C$gt

D$sum

Attempts:

3 left

💡 Hint

Common Mistakes

Using $sum instead of $count.

Using $gte instead of $gt.

Not quoting the field name in _id.

Group by "$category", count documents with $count, filter counts greater than 10 with $gt.

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