The $sum accumulator adds numeric values in each $group bucket—the workhorse for revenue totals, quantity rollups, point scores, and the classic $sum: 1 document count.
Add numeric fields.
Count documents.
Sum computed values.
Total vs mean.
Non-numbers ignored.
_id: null pattern.
$sum is a MongoDB accumulator used in the $group stage. For each group, it evaluates an expression on every document and returns the arithmetic total of all numeric results.
Think of $sum as a running plus sign across the group. Sales of 120, 85, and 200 yield 405. Pass the literal 1 instead of a field path to count how many documents landed in each bucket.
Use $sum for order totals, inventory quantities, game points, and KPI rollups. Pair with $avg when you need both total and mean, or with $sum: 1 to show how many records contributed to each total.
$sum takes one expression inside $group:
{
$group: {
_id: <expression>,
<outputField>: { $sum: <expression> }
}
}$group (also $bucket, windows).{ $sum: "$amount" } adds the field value per document.{ $sum: 1 } adds 1 per document (row count).{ $multiply: ["$price", "$qty"] }.0 when no numeric values contribute.db.orders.aggregate([
{
$group: {
_id: "$storeId",
totalSales: { $sum: "$amount" }
}
}
]);| Question | Answer |
|---|---|
| Stage | $group accumulator |
| Syntax | { $sum: <expression> } |
| Count docs | { $sum: 1 } |
| All non-numeric | Returns 0 |
vs $avg | $sum = total; $avg = total ÷ count |
| Common pairing | $match → $group → $sort |
{ $sum: "$amount" }Revenue per store
{ $sum: 1 }Orders per customer
{ $sum: {
$multiply: ["$price", "$qty"]
} }Line-item totals
{ _id: null,
total: { $sum: "$amount" } }Grand total
$sum accepts one expression inside $group:
expression RequiredNumeric value added per document. Can be a field path, the literal 1 for counting, or a computed expression.
{ $sum: "$quantity" }
{ $sum: 1 }_id Group keyDefines buckets. Use a field for per-category totals, compound keys for multi-field grouping, or null for one global bucket.
_id: "$storeId"return type NumberTypically int, long, double, or Decimal128 depending on input types. Mixed numeric types follow MongoDB’s numeric promotion rules.
405ignored inputs ImportantStrings, booleans, arrays, objects, null, and missing fields do not add to the total. Filter with $match when data quality is uncertain.
$match: { amount: { $type: "number" } }Sample order data—total sales per store, count orders, sum expressions, and compare with $avg.
Insert sample orders and compute total sales per store.
db.orders.insertMany([
{ orderId: "O1", storeId: "S1", amount: 120, quantity: 2 },
{ orderId: "O2", storeId: "S1", amount: 85, quantity: 1 },
{ orderId: "O3", storeId: "S2", amount: 200, quantity: 4 },
{ orderId: "O4", storeId: "S2", amount: 50, quantity: 1 },
{ orderId: "O5", storeId: "S1", amount: 95, quantity: 3 }
]);Store S1 has three orders (120 + 85 + 95 = 300). Store S2 has two orders (200 + 50 = 250).
db.orders.aggregate([
{
$group: {
_id: "$storeId",
totalSales: { $sum: "$amount" }
}
},
{ $sort: { totalSales: -1 } }
]);
/* Result:
[
{ _id: "S1", totalSales: 300 },
{ _id: "S2", totalSales: 250 }
]
*/Grouping by storeId creates one bucket per store. $sum adds every amount in that bucket.
Count documents, sum expressions, and compare with averages.
db.orders.aggregate([
{
$group: {
_id: "$storeId",
orderCount: { $sum: 1 },
totalSales: { $sum: "$amount" }
}
},
{ $sort: { _id: 1 } }
]);
/* S1 → orderCount: 3, totalSales: 300
S2 → orderCount: 2, totalSales: 250 */
*/$sum: 1 is the idiomatic way to count documents per group—often paired with field sums in the same $group stage.
db.orders.aggregate([
{
$group: {
_id: "$storeId",
totalQty: { $sum: "$quantity" }
}
},
{ $sort: { _id: 1 } }
]);
/* S1 → totalQty: 6 (2+1+3)
S2 → totalQty: 5 (4+1) */
*/You can sum any numeric field—or an expression like { $multiply: ["$price", "$quantity"] } for computed line totals.
db.orders.aggregate([
{
$group: {
_id: "$storeId",
totalSales: { $sum: "$amount" },
avgOrderSize: { $avg: "$amount" },
orderCount: { $sum: 1 }
}
},
{ $match: { _id: "S1" } }
]);
/* S1:
totalSales: 300
avgOrderSize: 100 (300 / 3)
orderCount: 3 */
*/$sum answers “how much in total?” $avg answers “what is the typical amount?” Use both when dashboards need revenue and average order value.
$sum WorksMongoDB assigns each document to a bucket based on the _id expression.
For each document, compute the $sum expression. Non-numeric results are skipped.
MongoDB adds each valid numeric value to the group’s accumulator (or adds 1 when using $sum: 1).
Each group outputs the final sum—or 0 if no numeric values contributed.
$sum is an accumulator in $group—not a query filter operator.$sum: 1 counts documents per group—the most common counting idiom in aggregation.$avg which returns null).$sum will skip them silently.$sum is the go-to MongoDB accumulator for additive totals: revenue per store, units shipped, points scored, and document counts via $sum: 1.
Filter with $match first, pair totals with $avg and counts for context, and use expressions when the value to add must be computed. Next: $top for ranked documents per group.
$sum: 1 alongside field sums to show count and total together$match before $group to sum only relevant documents{ $sum: { $multiply: […] } }$sum when you need a mean—use $avg instead"120" are summed—they are ignored$sum with update operator $inc on single documents_id: null still outputs _id: null in results$sumUse these points whenever you total numeric values in aggregation pipelines.
Total per group.
BasicsDocument count.
PatternAccumulator context.
SyntaxStrings ignored.
GotchaTotal vs mean.
CompareYou can manually compute $avg with $sum on a field and $sum: 1 for count, then divide in $project—but built-in $avg is clearer. The literal $sum: 1 pattern predates the dedicated $count stage and remains very common in tutorials and production pipelines. See the official $sum docs.
Total values with $sum, then learn $top for the highest-ranked document per group.
5 people found this page helpful