The $setEquals operator checks whether two or more arrays contain the same set of elements and returns true or false. Order and duplicates are ignored — perfect for comparing roles, tags, or permissions.
Same elements?
true or false.
[1,2] = [2,1].
All must match.
Roles, tags, ACLs.
Set vs ordered.
In MongoDB’s aggregation framework, the $setEquals operator compares two or more arrays as sets. It returns true when every array contains exactly the same unique elements, and false when they differ. For example, { $setEquals: [ [1, 2, 3], [3, 2, 1] ] } returns true.
This is different from $eq, which compares arrays in order. Use $setEquals when you care about membership, not sequence — such as verifying that a user’s roles match a template or that two tag lists are equivalent.
Duplicates are ignored: [1, 1, 2] and [2, 1] are equal sets. If you need exact ordered array equality, use $eq instead.
The $setEquals operator takes an array of two or more array expressions:
{ $setEquals: [ <array1>, <array2>, ... ] }{ $setEquals: [ [1, 2, 3], [3, 2, 1] ] }
// true — same set, different order
{ $setEquals: [ ["admin", "user"], ["user", "admin"] ] }
// true
{ $setEquals: [ [1, 2], [2, 3] ] }
// false — different elements
{ $setEquals: [ [1, 2], [1, 2], [2, 1] ] }
// true — all three matchtrue if all arrays represent the same set; otherwise false.[a, b] equals [b, a].null if any input array is null.$project, $addFields, $match (with $expr), or $cond.$setEquals: true, $eq: false| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (set / array) |
| Syntax | { $setEquals: [ arr1, arr2, ... ] } |
| Output | true or false |
| Order matters? | No |
| Common stages | $project, $match + $expr, $cond |
{
$setEquals: [
[1, 2, 3],
[3, 2, 1]
]
}→ true
{
$setEquals: [
"$roles",
"$expectedRoles"
]
}Role check
$expr: {
$setEquals: ["$a", "$b"]
}Filter docs
falseDifferent sets
Compare user roles to templates, verify tag lists, filter matching documents, and branch with $cond using $setEquals.
Verify whether a user’s roles match an expected role set.
Suppose you have a users collection:
[
{
"_id": 1,
"name": "Alice",
"roles": ["admin", "editor"],
"expectedRoles": ["editor", "admin"]
},
{
"_id": 2,
"name": "Bob",
"roles": ["viewer"],
"expectedRoles": ["viewer", "editor"]
},
{
"_id": 3,
"name": "Carol",
"roles": ["admin", "admin", "user"],
"expectedRoles": ["user", "admin"]
}
]Add a boolean flag comparing roles and expectedRoles:
db.users.aggregate([
{
$project: {
name: 1,
roles: 1,
expectedRoles: 1,
rolesMatch: {
$setEquals: [
"$roles",
"$expectedRoles"
]
}
}
}
])$setEquals ignores order and duplicates. Alice’s ["admin", "editor"] matches ["editor", "admin"].
Find documents with matching tag sets and label compliance status.
Keep only documents where roles equal expected roles:
db.users.aggregate([
{
$match: {
$expr: {
$setEquals: [
"$roles",
"$expectedRoles"
]
}
}
},
{
$project: { name: 1, roles: 1 }
}
])
// Returns Alice and Carol onlyWrap $setEquals in $expr inside $match so MongoDB evaluates it as an aggregation expression.
Check whether a product’s tags match a category template:
db.products.aggregate([
{
$lookup: {
from: "categories",
localField: "categoryId",
foreignField: "_id",
as: "category"
}
},
{ $unwind: "$category" },
{
$project: {
name: 1,
tagsMatchCategory: {
$setEquals: [
"$tags",
"$category.requiredTags"
]
}
}
}
])After $lookup, compare the product’s tags with the category’s required tag set. Useful for catalog validation rules.
Assign a human-readable status from the comparison result:
db.users.aggregate([
{
$project: {
name: 1,
compliance: {
$cond: [
{
$setEquals: [
"$roles",
"$expectedRoles"
]
},
"compliant",
"review needed"
]
}
}
}
])$cond uses the boolean from $setEquals as its condition. This pattern works well in audit and access-control reports.
Verify that three role sources all agree:
db.users.aggregate([
{
$project: {
name: 1,
allSourcesAgree: {
$setEquals: [
"$roles",
"$ldapRoles",
"$expectedRoles"
]
}
}
}
])
// true only when all three arrays are the same setPass more than two arrays. Every array must represent the same set for the result to be true.
$setEquals WorksAll arguments resolve to arrays (field paths, literals, or nested expressions).
Duplicates are removed and order is ignored for comparison purposes.
If every array contains exactly the same unique elements, the result is true.
Use in projections, filters, or conditional logic.
The $setEquals operator compares arrays as sets and returns true when they contain the same unique elements. Order and duplicates do not affect the result.
Use it for role checks, tag validation, and sync verification. For elements in A but not B, use $setDifference. Next in the series: $setField.
$setEquals when order and duplicates should not matter$expr when filtering with $match$ifNull to treat missing arrays as [] when appropriate$eq when exact ordered array equality is required[1, 2] and [2, 1] to differ — they are equal sets$setEquals for ordered list comparison (use $eq)$setIsSubset in MongoDB docs)$setEqualsUse these points when comparing arrays as sets in pipelines.
Boolean check.
PurposeTwo+ arrays.
SyntaxSet semantics.
RuleSet vs ordered.
Comparenull out.
Edge caseMove on to $setField for dynamic field access, or review $setDifference for set subtraction.
5 people found this page helpful