Bird
Raised Fist0
MongoDBquery~5 mins

$sum accumulator in MongoDB - Time & Space Complexity

Choose your learning style10 modes available
LearnWhyDeepVisualTryChallengeProjectRecallTime
Time Complexity: $sum accumulator
O(n)
Understanding Time Complexity

When using the $sum accumulator in MongoDB, it's important to understand how the time to calculate the sum grows as the data size increases.

We want to know: how does the work change when we add more documents to sum?

Scenario Under Consideration

Analyze the time complexity of the following MongoDB aggregation snippet.

db.sales.aggregate([
  { $group: { _id: "$store", totalSales: { $sum: "$amount" } } }
])

This groups sales by store and sums the amount for each store.

Identify Repeating Operations

Look for repeated actions that take time.

  • Primary operation: Summing the amount field for each document in the collection.
  • How many times: Once for each document in the input data.
How Execution Grows With Input

As the number of documents grows, the sum operation must add more numbers.

Input Size (n)Approx. Operations
1010 additions
100100 additions
10001000 additions

Pattern observation: The work grows directly with the number of documents; double the documents means double the additions.

Final Time Complexity

Time Complexity: O(n)

This means the time to compute the sum grows in a straight line with the number of documents.

Common Mistake

[X] Wrong: "The $sum accumulator runs instantly no matter how many documents there are."

[OK] Correct: Each document's value must be added, so more documents mean more work and more time.

Interview Connect

Understanding how aggregation operations like $sum scale helps you explain performance in real projects and shows you can think about data size impact clearly.

Self-Check

What if we changed the aggregation to group by two fields instead of one? How would the time complexity change?

Practice

(1/5)
1. What does the $sum accumulator do in a MongoDB aggregation pipeline?
easy
A. Adds values together or counts documents within groups
B. Finds the average value of a field
C. Sorts documents in ascending order
D. Filters documents based on a condition

Solution

  1. Step 1: Understand the role of $sum

    The $sum accumulator adds numeric values or counts documents when used in a $group stage.

  2. Step 2: Compare with other accumulators

    Unlike $avg which calculates averages, $sum only totals values or counts documents.

  3. Final Answer:

    Adds values together or counts documents within groups -> Option A

  4. Quick Check:

    $sum = Adds or counts [OK]
Hint: Remember: $sum totals numbers or counts docs [OK]
Common Mistakes:
  • Confusing $sum with $avg
  • Thinking $sum sorts data
  • Assuming $sum filters documents
2. Which of the following is the correct syntax to sum the field price in a $group stage?
easy
A. { $group: { _id: null, total: { $sum: "price" } } }
B. { $group: { _id: null, total: { $sum: "$price" } } }
C. { $group: { _id: null, total: { $sum: price } } }
D. { $group: { _id: null, total: { sum: "$price" } } }

Solution

  1. Step 1: Identify correct field reference syntax

    In MongoDB aggregation, field names must be prefixed with "$" inside expressions, so "$price" is correct.

  2. Step 2: Check accumulator syntax

    The accumulator must be $sum, not sum, and the value must be a string with "$" prefix.

  3. Final Answer:

    { $group: { _id: null, total: { $sum: "$price" } } } -> Option B

  4. Quick Check:

    Use $sum with "$field" syntax [OK]
Hint: Use "$field" inside $sum in $group [OK]
Common Mistakes:
  • Omitting the $ before field name
  • Using sum instead of $sum
  • Not quoting the field name
3. Given the collection documents:
{ "category": "A", "value": 10 }
{ "category": "A", "value": 20 }
{ "category": "B", "value": 5 }

What will be the output of this aggregation?
[{ $group: { _id: "$category", totalValue: { $sum: "$value" } } }]
medium
A. [{ "_id": "A", "totalValue": 30 }, { "_id": "B", "totalValue": 5 }]
B. [{ "_id": "A", "totalValue": 10 }, { "_id": "B", "totalValue": 5 }]
C. [{ "_id": "A", "totalValue": 20 }, { "_id": "B", "totalValue": 5 }]
D. [{ "_id": null, "totalValue": 35 }]

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 per group

    For category "A": 10 + 20 = 30; for category "B": 5.

  3. Final Answer:

    [{ "_id": "A", "totalValue": 30 }, { "_id": "B", "totalValue": 5 }] -> Option A

  4. Quick Check:

    Sum values per category [OK]
Hint: Sum values grouped by _id field [OK]
Common Mistakes:
  • Summing without grouping
  • Using null _id causing single group
  • Adding only one document's value
4. Consider this aggregation pipeline:
[{ $group: { _id: "$type", total: { $sum: value } } }]

What is the error in this pipeline?
medium
A. The _id field cannot be a string
B. Missing $group stage
C. Cannot use $sum inside $group
D. Field name 'value' should be quoted and prefixed with $ inside $sum

Solution

  1. Step 1: Check field reference inside $sum

    The field 'value' must be referenced as "$value" (string with $ prefix) inside $sum.

  2. Step 2: Confirm correct $group usage

    The $group stage is present and _id is correctly set to "$type".

  3. Final Answer:

    Field name 'value' should be quoted and prefixed with $ inside $sum -> Option D

  4. Quick Check:

    Use "$field" inside $sum [OK]
Hint: Always quote and prefix field with $ inside $sum [OK]
Common Mistakes:
  • Using unquoted field names inside $sum
  • Thinking $sum can't be used in $group
  • Misunderstanding _id usage
5. You have a collection of sales documents with fields store and amount. You want to find the total sales per store but only for stores with total sales above 1000. Which aggregation pipeline correctly uses $sum and filters the results?
hard
A. [{ $match: { amount: { $gt: 1000 } } }, { $group: { _id: "$store", totalSales: { $sum: "$amount" } } }]
B. [{ $group: { _id: "$store", totalSales: { $sum: "$amount" } } }, { $match: { amount: { $gt: 1000 } } }]
C. [{ $group: { _id: "$store", totalSales: { $sum: "$amount" } } }, { $match: { totalSales: { $gt: 1000 } } }]
D. [{ $group: { _id: "$store", totalSales: { $sum: "$amount" } } }, { $match: { _id: { $gt: 1000 } } }]

Solution

  1. Step 1: Group sales by store and sum amounts

    The first stage groups documents by "store" and sums the "amount" field into "totalSales".

  2. Step 2: Filter groups with totalSales greater than 1000

    The second stage uses $match on the aggregated field "totalSales" to keep only stores with totals above 1000.

  3. Final Answer:

    [{ $group: { _id: "$store", totalSales: { $sum: "$amount" } } }, { $match: { totalSales: { $gt: 1000 } } }] -> Option C

  4. Quick Check:

    Group then filter on sum field [OK]
Hint: Group first, then filter on summed field [OK]
Common Mistakes:
  • Filtering before grouping
  • Filtering on original amount instead of totalSales
  • Filtering on wrong field name
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard