$addToSet accumulator for unique arrays in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this aggregation using $addToSet?

Consider a collection orders with documents:

{ "_id": 1, "items": ["apple", "banana"] }
{ "_id": 2, "items": ["banana", "orange"] }
{ "_id": 3, "items": ["apple", "orange"] }

What will be the result of this aggregation?

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

MongoDB

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

A {"_id": null, "uniqueItems": ["apple", "banana", "orange"]}

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

C {"_id": null, "uniqueItems": ["banana", "orange"]}

D {"_id": null, "uniqueItems": ["apple", "orange"]}

💡 Hint

Think about how $unwind breaks arrays into single elements and $addToSet collects unique values.

The $unwind stage breaks each array element into its own document. Then $group with $addToSet collects all unique 'items' values into one array. Since all fruits appear across documents, the result is all unique fruits.

🧠 Conceptual

intermediate

What does $addToSet do in MongoDB aggregation?

Choose the best description of the $addToSet accumulator in MongoDB aggregation pipelines.

A Counts the number of documents in a group.

B Adds all values including duplicates to an array.

C Adds only unique values to an array, ignoring duplicates.

D Calculates the sum of numeric values.

💡 Hint

Think about how $addToSet handles duplicates.

$addToSet adds values to an array but only keeps unique values, removing duplicates automatically.

📝 Syntax

advanced

Which aggregation query correctly uses $addToSet to collect unique tags?

Given a collection posts with documents containing a tags array, which aggregation pipeline correctly collects all unique tags across all posts?

A db.posts.aggregate([{ $unwind: "$tags" }, { $group: { _id: null, allTags: { $push: "$tags" } } }])

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

C db.posts.aggregate([{ $group: { _id: null, allTags: { $push: "$tags" } } }])

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

💡 Hint

Remember $addToSet collects unique values, but if you add arrays directly, it won't flatten them.

Option B unwinds the tags array so each tag is a separate document, then $addToSet collects unique tags. Option B adds arrays as elements, not individual tags. Options C and D use $push which does not remove duplicates.

❓ optimization

advanced

How to optimize aggregation to collect unique values without $unwind?

You want to collect all unique tags from documents where each document has a tags array. Which approach is more efficient and correct?

A Use $unwind on tags, then $group with $addToSet on tags.

B Use $project to flatten tags, then $group with $push.

C Use $group with $addToSet directly on the tags array field.

D Use $group with $push on tags, then $unwind the result.

💡 Hint

Think about how $addToSet treats arrays versus individual elements.

Only by unwinding the array first can $addToSet collect unique individual tags. Using $addToSet on the array field adds whole arrays as elements, not individual tags.

🔧 Debug

expert

Why does this aggregation return nested arrays instead of unique values?

Given this aggregation:

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

Each tags field is an array. The result shows uniqueTags as arrays inside an array, not a flat unique list.
What is the cause?

A MongoDB does not support $addToSet on arrays.

B The _id field should be null to collect all tags.

C The $group stage is missing a $unwind before grouping.

D $addToSet adds the entire tags array as one element, causing nested arrays.

💡 Hint

Think about what happens when you add arrays to a set.

When $addToSet is used on an array field, it adds the whole array as a single element, resulting in nested arrays. To get unique individual elements, you must unwind first.