MongoDB $addToSet Accumulator

Example 1 — Sample Data

Imagine four orders. Each has a store, a city, and a tags array. Notice store A has New York twice—perfect for showing how $addToSet drops duplicates.

db.orders.insertMany([
  { store: "A", city: "New York", tags: ["sale", "new"] },
  { store: "A", city: "New York", tags: ["sale"] },
  { store: "A", city: "Chicago", tags: ["clearance"] },
  { store: "B", city: "New York", tags: ["new"] }
]);

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", tags: ["sale", "new"] },
  { store: "A", city: "New York", tags: ["sale"] },
  { store: "A", city: "Chicago", tags: ["clearance"] },
  { store: "B", city: "New York", tags: ["new"] }
]

Read each document like this:

Orders by store:

  Store A: New York, New York, Chicago
  Store B: New York

Notice Store A has "New York" twice —
$addToSet will keep it only once.

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 $addToSet in the next examples.

Example 2 — Unique Cities per Store

Goal: for each store, list every different city that appeared. _id: "$store" makes one group per store value.

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

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

How It Works

1. Split by store. _id: "$store" creates groups "A" and "B".
2. Read each city. For every document, $addToSet looks at $city.
3. Skip repeats. Store A sees New York twice; the second time it is already in the set, so nothing changes.
4. Add new values. Chicago is new for store A, so it is appended. Store B only ever sees New York.

Example 3 — $addToSet vs $push

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

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

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

How It Works

1. Same group key. Both fields use the same _id: "$store" groups.
2. Set drops the duplicate. Store A’s citiesSet has New York once.
3. Push keeps every visit. citiesAll lists New York twice because two orders used that city.
4. Pick by intent. Distinct report → $addToSet. Full history → $push.

Example 4 — Unique Tags after $unwind

Goal: unique tag strings per store. Without $unwind, $addToSet: "$tags" would treat each whole array as one element.

db.orders.aggregate([
  { $unwind: "$tags" },
  {
    $group: {
      _id: "$store",
      tags: { $addToSet: "$tags" }
    }
  },
  { $sort: { _id: 1 } }
]);

[
  { _id: "A", tags: [ "sale", "new", "clearance" ] },
  { _id: "B", tags: [ "new" ] }
]

How It Works

1. Flatten first. $unwind: "$tags" turns each tag into its own document.
2. Group by store. Store A now has documents for sale, new, sale, and clearance.
3. Deduplicate. $addToSet keeps sale once, then adds new and clearance.
4. Without unwind. You would get arrays-of-arrays (whole tags values), not individual strings.