MongoDB $lastN Accumulator

Example 1 — Sample Data

Imagine six orders across stores A and B. Each document has a store, product, and amount.

db.orders.insertMany([
  { store: "A", product: "Laptop", amount: 1200 },
  { store: "A", product: "Mouse", amount: 25 },
  { store: "A", product: "Keyboard", amount: 75 },
  { store: "A", product: "Monitor", amount: 300 },
  { store: "B", product: "Laptop", amount: 1100 },
  { store: "B", product: "Headset", amount: 80 }
]);

How the Data Is Stored in MongoDB

After the insert, MongoDB keeps 6 documents in orders. Run find() to see them:

db.orders.find()

[
  { store: "A", product: "Laptop", amount: 1200 },
  { store: "A", product: "Mouse", amount: 25 },
  { store: "A", product: "Keyboard", amount: 75 },
  { store: "A", product: "Monitor", amount: 300 },
  { store: "B", product: "Laptop", amount: 1100 },
  { store: "B", product: "Headset", amount: 80 }
]

Read each document like this:

Store A order stream (as inserted):
  Laptop, Mouse, Keyboard, Monitor

Next: $lastN keeps the last N values in that order.

How It Works

1. Insert once. The sample command adds 6 documents to orders.
2. MongoDB stores fields as written. Each document keeps the same field names and values you inserted.
3. find() shows the same shape. What you inserted is what you get back—ready for $lastN in the next examples.

Example 2 — Last 2 in Document Order

Goal: for each store, keep the last two product values as they appear in the collection (no sort). Store A has four orders, so we only keep the trailing two.

db.orders.aggregate([
  {
    $group: {
      _id: "$store",
      lastProducts: {
        $lastN: {
          input: "$product",
          n: 2
        }
      }
    }
  },
  { $sort: { _id: 1 } }
]);

[
  { _id: "A", lastProducts: [ "Keyboard", "Monitor" ] },
  { _id: "B", lastProducts: [ "Laptop", "Headset" ] }
]

How It Works

1. Split by store. _id: "$store" makes groups "A" and "B".
2. Read product names. input: "$product" is what gets pushed into the result array.
3. Keep only the trailing n. With n: 2, store A keeps Keyboard and Monitor (drops Laptop and Mouse).
4. Short groups are fine. Store B only has two orders, so both products appear.
5. Need one value only? Use $last instead of $lastN.

Example 3 — Last 2 After $sort

Goal: last two products per store after sorting by highest amount first. Those trailing values are the cheaper items. $lastN does not sort—so we $sort before $group.

db.orders.aggregate([
  // Highest amount first — trailing docs = cheaper items
  { $sort: { amount: -1 } },
  {
    $group: {
      _id: "$store",
      lastProducts: {
        $lastN: {
          input: "$product",
          n: 2
        }
      }
    }
  },
  { $sort: { _id: 1 } }
]);

[
  { _id: "A", lastProducts: [ "Keyboard", "Mouse" ] },
  { _id: "B", lastProducts: [ "Laptop", "Headset" ] }
]

How It Works

1. Sort the pipeline. { amount: -1 } puts expensive orders ahead of cheap ones.
2. Group still buckets by store. Within each bucket, documents keep the sorted order.
3. Last N now means “cheapest after that sort”. Store A: Keyboard (75), then Mouse (25).
4. Contrast Example 2. Without sort, store A was Keyboard + Monitor. With sort, Monitor is replaced by Mouse.
5. Rank inside the accumulator? Use $bottomN with sortBy instead of a separate $sort.