The $setUnion operator merges two or more arrays into a single list of unique elements. Use it to combine tags, roles, skills, or permissions from multiple sources without duplicates.
Combine sets.
Unique only.
Any number.
$project / $addFields.
Roles, tags.
Intersect, diff.
In MongoDB’s aggregation framework, the $setUnion operator takes two or more arrays and returns every unique element found in any of them. For example, { $setUnion: [ [1, 2, 3], [2, 3, 4] ] } returns [1, 2, 3, 4].
Think of it as combining Venn diagram circles into one set — every value from every array is included, but each value appears only once in the result.
Need only shared elements? Use $setIntersection. Need elements in A but not B? Use $setDifference. Need everything combined uniquely? Use $setUnion.
The $setUnion operator takes an array of two or more array expressions:
{ $setUnion: [ <array1>, <array2>, ... ] }{ $setUnion: [ [1, 2, 3], [2, 3, 4] ] }
// Result: [1, 2, 3, 4]
{ $setUnion: [ ["a", "b"], ["b", "b", "c"], ["c", "d"] ] }
// Result: ["a", "b", "c", "d"] (duplicates removed)
{ $setUnion: [ [1, 2], [3, 4] ] }
// Result: [1, 2, 3, 4] (no overlap, all included)null if any input array is null.$project, $addFields, or $set.[1, 2, 3, 4] (all unique)[2, 3] (in both)[1] (in A only)[1,2,3,2,3,4] (keeps dupes)| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (set / array) |
| Syntax | { $setUnion: [ arr1, arr2, ... ] } |
| Minimum arrays | Two |
| Output | Array of unique combined elements |
| Duplicates | Removed automatically |
{
$setUnion: [
[1, 2, 3],
[2, 3, 4]
]
}→ [1, 2, 3, 4]
{
$setUnion: [
"$dbRoles",
"$ldapRoles"
]
}Merged roles
[
"$a", "$b", "$c"
]All combined
{ $size: "..." }How many unique
Merge role lists from multiple sources, combine user tags, unify permissions, and count unique values with $setUnion.
Combine roles stored in the database with roles from an LDAP directory.
Suppose you have a users collection with roles from two sources:
[
{
"_id": 1,
"name": "Alice",
"dbRoles": ["editor", "viewer"],
"ldapRoles": ["viewer", "moderator"]
},
{
"_id": 2,
"name": "Bob",
"dbRoles": ["admin"],
"ldapRoles": ["admin", "editor"]
},
{
"_id": 3,
"name": "Carol",
"dbRoles": [],
"ldapRoles": ["viewer"]
}
]Build a single deduplicated role list for each user:
db.users.aggregate([
{
$project: {
name: 1,
dbRoles: 1,
ldapRoles: 1,
allRoles: {
$setUnion: [
"$dbRoles",
"$ldapRoles"
]
}
}
}
])viewer appears in both source arrays for Alice but only once in the result. Every unique role from either source is included.
Combine interest tags, merge permission grants, and measure set size.
Build a unified tag list for search indexing or recommendations:
db.recommendations.aggregate([
{
$project: {
user: 1,
combinedTags: {
$setUnion: [
"$userTags",
"$articleTags"
]
}
}
}
])
// userTags: ["mongodb", "nodejs"]
// articleTags: ["mongodb", "database"]
// combinedTags: ["mongodb", "nodejs", "database"]Use the merged list for full-text search facets, content discovery, or feeding into a recommendation engine.
Merge permissions from database roles, LDAP groups, and policy grants:
db.users.aggregate([
{
$project: {
name: 1,
effectivePermissions: {
$setUnion: [
"$dbPermissions",
"$ldapPermissions",
"$policyGrants"
]
}
}
}
])Pass three or more arrays. Every unique permission from any source appears once in the combined result.
Measure how many distinct skills a candidate has across multiple assessments:
db.candidates.aggregate([
{
$project: {
name: 1,
totalUniqueSkills: {
$size: {
$setUnion: [
"$technicalSkills",
"$softSkills",
"$certifications"
]
}
}
}
}
])Wrap $setUnion in $size to get a numeric count of unique combined values.
See why set union is better when you need deduplication:
// $concatArrays — keeps duplicates
{ $concatArrays: [ [1, 2, 3], [2, 3, 4] ] }
// → [1, 2, 3, 2, 3, 4]
// $setUnion — unique combined set
{ $setUnion: [ [1, 2, 3], [2, 3, 4] ] }
// → [1, 2, 3, 4]Use $concatArrays when order and duplicates matter (like concatenating log entries). Use $setUnion when you need a unique membership list.
$setUnion WorksAll arguments resolve to arrays (field paths, literals, or nested expressions).
Every value from every input array is gathered into one combined set.
Set semantics ensure each value appears only once in the final result array.
Use with $size for counts or store as an enriched field.
The $setUnion operator merges multiple arrays into one deduplicated set. It is the standard tool for combining roles, tags, skills, or permissions from different sources inside aggregation pipelines.
Pair it with $size to count unique combined values. For overlap checks, use $setIntersection; for subtraction, use $setDifference. Next in the series: $sin.
$setUnion when you need a unique combined membership list$size to count distinct combined values$ifNull when fields may be missing$setIntersection when you only need shared elements$setUnion when you need to preserve duplicate entries$concatArrays when deduplication is required$setUnionUse these points when merging arrays as sets in pipelines.
All unique values.
PurposeTwo+ arrays.
SyntaxSet semantics.
OutputCount unique.
ChainingDedupe vs keep.
CompareMove on to $sin for trigonometric calculations, or review $setIntersection for overlap logic.
5 people found this page helpful