MongoDB $push Accumulator

Example 1 — Sample Data

Imagine four orders. Each has a store, a city, and an amount. Store A visits New York twice—perfect for showing how $push keeps duplicates.

db.orders.insertMany([
  { store: "A", city: "New York", amount: 120 },
  { store: "A", city: "New York", amount: 40 },
  { store: "A", city: "Chicago", amount: 90 },
  { store: "B", city: "New York", amount: 75 }
]);

How the Data Is Stored in MongoDB

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

db.orders.find()

[
  { store: "A", city: "New York", amount: 120 },
  { store: "A", city: "New York", amount: 40 },
  { store: "A", city: "Chicago", amount: 90 },
  { store: "B", city: "New York", amount: 75 }
]

Read each document like this:

Store A cities in order:
  New York, New York, Chicago

$push keeps every value — including duplicates.

How It Works

1. Insert once. The sample command adds 4 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 $push in the next examples.

Example 2 — Push Cities per Store

Goal: for each store, list every city that appeared—including repeats.

db.orders.aggregate([
  {
    $group: {
      _id: "$store",
      cities: { $push: "$city" }
    }
  },
  { $sort: { _id: 1 } }
]);

[
  { _id: "A", cities: [ "New York", "New York", "Chicago" ] },
  { _id: "B", cities: [ "New York" ] }
]

How It Works

1. Split by store. _id: "$store" makes groups "A" and "B".
2. Append each city. Every document contributes one array element.
3. Duplicates stay. Store A’s New York appears twice because two orders used that city.
4. Order follows arrival. Without a prior $sort, order matches how documents enter the group.

Example 3 — $push vs $addToSet

Same grouping, two accumulators side by side. $push keeps every city; $addToSet keeps each city once.

db.orders.aggregate([
  {
    $group: {
      _id: "$store",
      citiesAll: { $push: "$city" },
      citiesSet: { $addToSet: "$city" }
    }
  },
  { $sort: { _id: 1 } }
]);

[
  {
    _id: "A",
    citiesAll: [ "New York", "New York", "Chicago" ],
    citiesSet: [ "New York", "Chicago" ]
  },
  {
    _id: "B",
    citiesAll: [ "New York" ],
    citiesSet: [ "New York" ]
  }
]

How It Works

1. Same group key. Both fields use _id: "$store".
2. Push keeps every visit. Store A lists New York twice.
3. Set drops the duplicate. citiesSet has New York once.
4. Pick by intent. Full history → $push. Distinct report → $addToSet.

Example 4 — Push Objects After $sort

Goal: for each store, build an array of { city, amount } ordered by highest amount first. $push does not sort—so we $sort before $group.

db.orders.aggregate([
  { $sort: { amount: -1 } },
  {
    $group: {
      _id: "$store",
      orders: {
        $push: {
          city: "$city",
          amount: "$amount"
        }
      }
    }
  },
  { $sort: { _id: 1 } }
]);

[
  {
    _id: "A",
    orders: [
      { city: "New York", amount: 120 },
      { city: "Chicago", amount: 90 },
      { city: "New York", amount: 40 }
    ]
  },
  {
    _id: "B",
    orders: [
      { city: "New York", amount: 75 }
    ]
  }
]

How It Works

1. Sort first. { amount: -1 } puts larger amounts ahead.
2. Push an object. Each element is { city, amount }, not a bare string.
3. Order is preserved. Store A: 120, then 90, then 40.
4. Need only the first few? Prefer $firstN after the same sort instead of pushing everything.