$sum, $avg, $min, $max: 숫자 집계

MongoDB's $group stage uses accumulators to compute aggregate values from grouped documents. The most fundamental numeric accumulators are $sum, $avg, $min, and $max. Each accumulator processes all documents in a group and produces a single output value. These operators form the backbone of analytics pipelines.

The $sum accumulator has two common uses: counting documents by passing a literal value like 1, and summing a field by referencing a numeric field. When a field is missing or null, $sum treats it as zero. This makes it safe to use on optional numeric fields without extra null-checks.

The $avg accumulator computes the arithmetic mean of a numeric field across all documents in a group. It automatically ignores documents where the field is missing or null, computing the average only over valid values. This is useful for metrics like average order value or average rating per product.

$min and $max return the smallest and largest values in a group respectively. They work on any comparable type—numbers, dates, and strings. A common use case is finding the first and last event times within a session, or the cheapest and most expensive product in a category. They ignore null and missing values.

To compute a single aggregate over the entire collection, set the _id to null. This groups all documents into one bucket. This technique is how you calculate totals, overall averages, and global extremes without segmenting data. Think of it as the MongoDB equivalent of a SQL SELECT SUM(*) FROM orders with no GROUP BY clause.

A lesser-known feature is that $sum, $avg, $min, and $max can also be used as expression operators in $project—not just in $group. In this context, they operate on an array within a single document rather than across multiple documents. This allows you to compute the sum of elements in an embedded array field without a $group stage.

Accumulators accept any valid expression, not just field references. You can use arithmetic operators, conditional expressions, and even $cond inside an accumulator. This lets you implement conditional sums like 'sum only completed orders' or 'count only high-value transactions' in a single pipeline stage.

You can chain multiple $group stages to compute multi-level aggregations. A first group computes per-day totals, and a second group computes monthly averages from those daily totals. This pattern is cleaner than doing everything in one stage and makes the pipeline logic easier to reason about.

Always place a $match stage before $group to filter down to the relevant documents first. This reduces the number of documents the grouping stage must process and, crucially, allows MongoDB to use an index to satisfy the filter. A $match after $group filters group results, which is also useful but does not benefit from indexes.

When a field referenced in $sum or $avg is missing or null, the behavior differs slightly. $sum treats missing/null as zero, so all documents contribute to the count. $avg and $min/$max ignore missing/null values entirely—they do not factor into the computation. Understanding this distinction prevents subtle bugs in your analytics queries.

Combining $sum, $avg, $min, and $max in one $group stage is a common pattern for dashboard metrics. A single aggregation pipeline can return everything needed to populate a summary card: total orders, revenue, average order value, and the range of order sizes. This avoids multiple round-trips to the database.

In this lesson you learned: $sum totals values and counts documents (missing = 0), $avg/$min/$max ignore missing or null fields, and these accumulators work in both $group (across documents) and $project (within an array). Next up we explore $push and $addToSet for building arrays within groups.