Aggregation Expressions

What we're doing: Compute a line-item total and a display label from raw fields, in one $set stage.

db.orderItems.aggregate([
  { $set: {
      lineTotal: { $multiply: ["$unitPrice", "$quantity"] },
      label: { $concat: ["$sku", " x", { $toString: "$quantity" }] }
  } }
])

2

$multiply takes an array of expressions and multiplies them — here, two field references.

3

$concat only accepts strings, so $toString converts the numeric quantity before joining it in.

Why this works: Expressions compose the same way normal function calls do — an expression can be another expression's argument, which is how one $set stage builds several derived fields from the same raw data.

What we're doing: Classify orders into a shipping tier using $switch, with $ifNull filling a missing region before the check.

db.orders.aggregate([
  { $set: { region: { $ifNull: ["$region", "unknown"] } } },
  { $set: { shipping: { $switch: {
      branches: [
        { case: { $eq: ["$region", "unknown"] }, then: "hold" },
        { case: { $eq: ["$region", "domestic"] }, then: "standard" }
      ],
      default: "international"
  } } } }
])

2

A missing region becomes the literal string "unknown" before anything else inspects it, so the switch never has to handle a null case separately.

3

$switch checks branches top to bottom; the first matching case wins and the rest are skipped.

Why this works: Running $ifNull first collapses the missing-field case into a normal value the rest of the pipeline can compare against, which keeps every later $switch branch a simple equality check.

What we're doing: From an order's line-items array, keep only shipped items and sum their totals — without $unwind.

db.orders.aggregate([
  { $set: {
      shippedItems: { $filter: {
          input: "$items",
          as: "item",
          cond: { $eq: ["$$item.status", "shipped"] }
      } }
  } },
  { $set: {
      shippedTotal: { $reduce: {
          input: "$shippedItems",
          initialValue: 0,
          in: { $add: ["$$value", "$$this.price"] }
      } }
  } }
])

3

$filter walks the items array and keeps only elements where status equals "shipped" — the document count stays exactly one.

8

$reduce walks the filtered array once, carrying a running sum in $$value and the current element in $$this, ending with a single number.

Why this works: The whole computation happens on one document's array field, in place — no stage ever multiplies the document count, which is what $unwind followed by $group would otherwise require to reach the same single total.

What we're doing: Group orders by calendar day, in the customer's local timezone, and count them.

db.orders.aggregate([
  { $group: {
      _id: { $dateToString: { date: "$placedAt", format: "%Y-%m-%d", timezone: "America/New_York" } },
      count: { $sum: 1 }
  } },
  { $sort: { _id: 1 } }
])

3

Formatting to just the year-month-day string collapses every order placed on the same calendar day into one group, regardless of the time of day it was placed.

Why this works: Passing a timezone matters here specifically because a day boundary in UTC and a day boundary in America/New_York are several hours apart — without it, orders near midnight would land in the wrong day's bucket for that customer.

What we're doing: Coerce a price field that arrives as a string on some documents into a decimal, defaulting bad or missing values to 0 instead of failing the whole pipeline.

db.importedRows.aggregate([
  { $set: {
      price: { $convert: { input: "$price", to: "decimal", onError: 0, onNull: 0 } }
  } }
])

3

onError catches a string like "N/A" that cannot become a decimal; onNull catches a missing or null price field — both fall back to 0 instead of aborting the aggregation.

Why this works: A single malformed row in a large import should not stop the whole pipeline from producing results for every other row — onError/onNull turn a hard failure into a value you can filter or flag afterward.