$addToSet accumulator for unique arrays in MongoDB - Step-by-Step Execution

Concept Flow - $addToSet accumulator for unique arrays

Start aggregation

↓

Group documents

↓

For each group

↓

Check if value in array?

Yes→Skip adding

No↓

Add value to array

↓

Return unique array per group

The $addToSet accumulator collects unique values into an array for each group during aggregation.

Execution Sample

MongoDB

db.sales.aggregate([
  { $group: {
      _id: "$item",
      uniqueStores: { $addToSet: "$store" }
  }}
])

Groups sales by item and collects unique store names into an array for each item.

Execution Table

Step	Document Processed	Current Group (_id)	Current uniqueStores Array	Action Taken
1	{item: 'apple', store: 'A'}	apple	[]	Add 'A' to uniqueStores
2	{item: 'apple', store: 'B'}	apple	['A']	Add 'B' to uniqueStores
3	{item: 'apple', store: 'A'}	apple	['A', 'B']	Skip 'A' (already in uniqueStores)
4	{item: 'banana', store: 'A'}	banana	[]	Add 'A' to uniqueStores
5	{item: 'banana', store: 'C'}	banana	['A']	Add 'C' to uniqueStores
6	{item: 'banana', store: 'C'}	banana	['A', 'C']	Skip 'C' (already in uniqueStores)
7	{item: 'apple', store: 'C'}	apple	['A', 'B']	Add 'C' to uniqueStores
8	No more documents	-	Final arrays per group	Aggregation complete

💡 All documents processed; unique arrays built per group.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	After 6	After 7	Final
uniqueStores for 'apple'	[]	['A']	['A', 'B']	['A', 'B']	['A', 'B']	['A', 'B']	['A', 'B']	['A', 'B', 'C']	['A', 'B', 'C']
uniqueStores for 'banana'	[]	[]	[]	['A']	['A', 'C']	['A', 'C']	['A', 'C']	['A', 'C']	['A', 'C']

Key Moments - 2 Insights

Why does $addToSet skip adding a value that already exists in the array?

Because $addToSet ensures uniqueness by checking if the value is already present before adding, as shown in steps 3 and 6 where duplicates are skipped.

What happens if the group is empty when $addToSet starts?

The array starts empty ([]) and values are added only if they are not duplicates, as seen at step 1 for 'apple' and step 4 for 'banana'.

Visual Quiz - 3 Questions

Look at the execution table, what is the uniqueStores array for 'apple' after processing step 2?

A ['A']

B ['A', 'B']

C []

D ['B']

💡 Hint

Check the 'Current uniqueStores Array' column at step 2 for group 'apple'.

At which step does the uniqueStores array for 'banana' first include 'C'?

A Step 4

B Step 6

C Step 5

D Step 3

💡 Hint

Look at the 'Current uniqueStores Array' for 'banana' and see when 'C' is added.

If a new document {item: 'apple', store: 'B'} is processed after step 7, what happens?

A 'B' is skipped because it is already in uniqueStores

B uniqueStores resets to empty

C 'B' is added again to uniqueStores

D An error occurs

💡 Hint

Refer to steps 3 and 6 where duplicates are skipped.

Concept Snapshot

$addToSet accumulator syntax:
{ $group: { _id: <groupKey>, uniqueArray: { $addToSet: <expression> } } }

Behavior:
- Collects unique values per group into an array
- Skips duplicates automatically

Key rule:
- Result arrays contain no repeated values
- Useful for gathering distinct elements in aggregation

Full Transcript

The $addToSet accumulator in MongoDB aggregation groups documents by a key and collects unique values into an array for each group. It processes each document, checks if the value is already in the array, and adds it only if it is not present. This ensures the resulting array contains unique elements. For example, grouping sales by item and collecting unique store names uses $addToSet to avoid duplicates. The execution table shows step-by-step how values are added or skipped. Beginners often wonder why duplicates are skipped or how the array starts empty; these are clarified by tracing the array state changes. This accumulator is essential for building distinct lists within aggregation pipelines.

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