$addToSet accumulator for unique arrays in MongoDB

Introduction

The $addToSet accumulator helps you collect unique values into an array without duplicates.

When you want to gather all unique tags used in blog posts.

When you need a list of unique product categories from sales data.

When collecting unique user IDs who liked a post.

When summarizing unique cities customers come from.

When you want to avoid duplicate entries in an array during aggregation.

Syntax

MongoDB

db.collection.aggregate([
  {
    $group: {
      _id: <grouping_key>,
      uniqueValues: { $addToSet: <expression> }
    }
  }
])

$addToSet adds values to an array only if they are not already present.

The _id field defines how documents are grouped.

Examples

Groups orders by customer and collects unique product IDs each customer bought.

MongoDB

db.orders.aggregate([
  {
    $group: {
      _id: "$customerId",
      uniqueProducts: { $addToSet: "$productId" }
    }
  }
])

Collects unique arrays of tags from all posts (note: if tags is an array, this collects arrays, not individual tags).

MongoDB

db.posts.aggregate([
  {
    $group: {
      _id: null,
      uniqueTags: { $addToSet: "$tags" }
    }
  }
])

Unwinds tags array to get individual tags, then collects unique tags across all posts.

MongoDB

db.posts.aggregate([
  {
    $unwind: "$tags"
  },
  {
    $group: {
      _id: null,
      uniqueTags: { $addToSet: "$tags" }
    }
  }
])

Sample Program

This example inserts sales data with customers and their purchased items (some repeated). Then it unwinds the items array to single items and groups by customer to collect unique items each customer bought.

MongoDB

db.sales.insertMany([
  { _id: 1, customer: "Alice", items: ["apple", "banana", "apple"] },
  { _id: 2, customer: "Bob", items: ["banana", "orange"] },
  { _id: 3, customer: "Alice", items: ["banana", "kiwi"] }
])

db.sales.aggregate([
  { $unwind: "$items" },
  { $group: {
      _id: "$customer",
      uniqueItems: { $addToSet: "$items" }
    }
  }
])

Important Notes

Time complexity: Generally O(n) where n is number of documents processed.

Space complexity: Depends on number of unique values collected per group.

Common mistake: Using $addToSet on arrays without $unwind collects arrays as elements, not individual values.

Use $addToSet when you want unique values; use $push if duplicates are allowed.

Summary

$addToSet collects unique values into an array during aggregation.

Use $unwind before $addToSet to get unique elements from arrays.

Great for removing duplicates in grouped results.

Practice

1. What does the $addToSet accumulator do in a MongoDB aggregation pipeline?

easy

A. Counts the total number of documents in a group

B. Adds all values including duplicates into an array

C. Sorts the array elements in ascending order

D. Collects unique values into an array, avoiding duplicates

Solution

1. Step 1: Understand $addToSet purpose

   $addToSet collects values but only keeps unique ones, no duplicates.

2. Step 2: Compare with other accumulators

   Unlike $push which adds all values, $addToSet ensures uniqueness.

3. Final Answer:

   Collects unique values into an array, avoiding duplicates -> Option D

4. Quick Check:

   $addToSet = unique array [OK]

Hint: Remember: $addToSet means add unique only [OK]

Common Mistakes:

• Confusing $addToSet with $push
• Thinking it sorts the array
• Assuming it counts documents

2. Which of the following is the correct syntax to use $addToSet in a MongoDB aggregation $group stage?

easy

A. { $group: { _id: "$category", uniqueItems: { $addToSet: "$item" } } }

B. { $group: { _id: "$category", uniqueItems: { $push: "$item" } } }

C. { $group: { _id: "$category", uniqueItems: { $addToSet: ["$item"] } } }

D. { $group: { _id: "$category", uniqueItems: { $addToSet: { $item } } } }

Solution

1. Step 1: Identify correct $addToSet usage

   The correct syntax uses $addToSet with a field path as a string, like "$item".

2. Step 2: Check other options for errors

   { $group: { _id: "$category", uniqueItems: { $push: "$item" } } } uses $push, not $addToSet. { $group: { _id: "$category", uniqueItems: { $addToSet: ["$item"] } } } wrongly wraps field in array. { $group: { _id: "$category", uniqueItems: { $addToSet: { $item } } } } uses braces incorrectly.

3. Final Answer:

   { $group: { _id: "$category", uniqueItems: { $addToSet: "$item" } } } -> Option A

4. Quick Check:

   Correct syntax = { $group: { _id: "$category", uniqueItems: { $addToSet: "$item" } } } [OK]

Hint: Use field path as string inside $addToSet [OK]

Common Mistakes:

• Wrapping field in array inside $addToSet
• Using $push instead of $addToSet
• Using braces {} incorrectly around field

3. Given the collection documents:

{ "category": "fruit", "item": "apple" }

{ "category": "fruit", "item": "banana" }

{ "category": "fruit", "item": "apple" }

What will be the result of this aggregation?

[{ $group: { _id: "$category", uniqueItems: { $addToSet: "$item" } } }]

medium

A. { "_id": "fruit", "uniqueItems": ["apple", "banana"] }

B. { "_id": "fruit", "uniqueItems": ["apple", "apple", "banana"] }

C. { "_id": "fruit", "uniqueItems": ["banana"] }

D. { "_id": "fruit", "uniqueItems": [] }

Solution

1. Step 1: Group by category and collect unique items

   All documents have category "fruit". $addToSet collects unique "item" values.

2. Step 2: Identify unique items

   Items are "apple", "banana", and another "apple" (duplicate). Unique set is ["apple", "banana"].

3. Final Answer:

   { "_id": "fruit", "uniqueItems": ["apple", "banana"] } -> Option A

4. Quick Check:

   Unique items = ["apple", "banana"] [OK]

Hint: Duplicates removed, only unique values remain [OK]

Common Mistakes:

• Expecting duplicates in result array
• Confusing $addToSet with $push
• Ignoring grouping key

4. You wrote this aggregation but it throws an error:

[{ $group: { _id: "$category", uniqueItems: { $addToSet: item } } }]

What is the error and how to fix it?

medium

A. Wrong accumulator; use $push instead of $addToSet

B. Missing quotes around field path; fix by using "$item"

C. Missing $unwind stage before $group

D. Cannot use $addToSet inside $group

Solution

1. Step 1: Identify syntax error in field reference

   Field paths must be strings with "$" prefix inside accumulators. Here, item is missing quotes and $.

2. Step 2: Correct the syntax

   Change item to "$item" to fix the error.

3. Final Answer:

   Missing quotes around field path; fix by using "$item" -> Option B

4. Quick Check:

   Field path needs "$" and quotes [OK]

Hint: Always quote field paths with $ inside accumulators [OK]

Common Mistakes:

• Forgetting $ before field name
• Not quoting field path as string
• Assuming $unwind is always required

5. You have documents with a field tags as arrays, some with duplicates:

{ "_id": 1, "tags": ["red", "blue", "red"] }

{ "_id": 2, "tags": ["blue", "green"] }

Which aggregation pipeline will produce a single array of all unique tags across documents?

hard

A. [{ $project: { uniqueTags: { $addToSet: "$tags" } } }]

B. [{ $group: { _id: null, allTags: { $addToSet: "$tags" } } }]

C. [{ $unwind: "$tags" }, { $group: { _id: null, allTags: { $addToSet: "$tags" } } }]

D. [{ $unwind: "$tags" }, { $group: { _id: "$tags", count: { $sum: 1 } } }]

Solution

1. Step 1: Use $unwind to flatten tags arrays

   $unwind breaks each array element into separate documents, allowing unique collection.

2. Step 2: Group all tags into a unique set

   Grouping by null collects all tags into one array with $addToSet ensuring uniqueness.

3. Final Answer:

   [{ $unwind: "$tags" }, { $group: { _id: null, allTags: { $addToSet: "$tags" } } }] -> Option C

4. Quick Check:

   Unwind then addToSet = unique combined array [OK]

Hint: Unwind arrays before addToSet to get unique elements [OK]

Common Mistakes:

• Trying to addToSet whole arrays without unwind
• Using $project instead of $group for aggregation
• Grouping by tags instead of null for combined result