The $setIsSubset operator checks whether the first array is a subset of the second — every element in array1 must also appear in array2. Use it for role validation, skill requirements, tag whitelists, and permission checks.
A contained in B?
true or false.
Exactly two inputs.
Order ignored.
Roles, skills, tags.
Equals, union.
In MongoDB’s aggregation framework, the $setIsSubset operator compares two arrays as sets and returns true when every element in the first array is also present in the second. For example, { $setIsSubset: [ [1, 2], [1, 2, 3, 4] ] } returns true because 1 and 2 are both in the second array.
Read it as “Is A contained in B?” — not the other way around. If A has an element that B lacks, the result is false. An empty first array is always a subset of any second array.
To verify a candidate has all required skills, put requiredSkills first and candidateSkills second: { $setIsSubset: [ "$requiredSkills", "$candidateSkills" ] }.
The $setIsSubset operator takes exactly two array expressions:
{ $setIsSubset: [ <array1>, <array2> ] }{ $setIsSubset: [ [1, 2], [1, 2, 3, 4] ] }
// true — 1 and 2 are both in the second array
{ $setIsSubset: [ [1, 2, 5], [1, 2, 3, 4] ] }
// false — 5 is not in the second array
{ $setIsSubset: [ [], [1, 2, 3] ] }
// true — empty set is subset of any set
{ $setIsSubset: [ [1, 2], [2, 1] ] }
// true — order does not mattertrue if every element of array1 is in array2; otherwise false.true.null if either input array is null.$project, $addFields, $match (with $expr), or $cond.true (A is inside B)false (B is not inside A)false (different sets)[1, 2] (shared elements)| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (set / array) |
| Syntax | { $setIsSubset: [ arr1, arr2 ] } |
| Array count | Exactly two |
| Output | true or false |
| Meaning | Every element of arr1 is in arr2 |
| Common stages | $project, $match + $expr, $cond |
{
$setIsSubset: [
[1, 2],
[1, 2, 3, 4]
]
}→ true
{
$setIsSubset: [
"$requiredSkills",
"$candidateSkills"
]
}Has all required
{
$setIsSubset: [
"$userRoles",
"$allowedRoles"
]
}Role validation
[ [], "$any" ]→ true
Validate user roles against allowed lists, check job skill requirements, filter qualified candidates, and label compliance with $setIsSubset.
Check whether a user’s roles are contained in an allowed role list.
Suppose you have a users collection:
[
{
"_id": 1,
"name": "Alice",
"roles": ["editor", "viewer"],
"allowedRoles": ["admin", "editor", "viewer", "moderator"]
},
{
"_id": 2,
"name": "Bob",
"roles": ["admin", "superuser"],
"allowedRoles": ["admin", "editor", "viewer"]
},
{
"_id": 3,
"name": "Carol",
"roles": [],
"allowedRoles": ["viewer"]
}
]Verify every role in roles appears in allowedRoles:
db.users.aggregate([
{
$project: {
name: 1,
roles: 1,
allowedRoles: 1,
rolesAllowed: {
$setIsSubset: [
"$roles",
"$allowedRoles"
]
}
}
}
])Each value in the first array must exist in the second. Bob has superuser, which is not allowed, so the result is false.
Skill requirements, tag whitelists, and qualified-candidate filters.
Put required skills first and candidate skills second:
db.applications.aggregate([
{
$project: {
candidate: 1,
jobTitle: 1,
meetsRequirements: {
$setIsSubset: [
"$requiredSkills",
"$candidateSkills"
]
}
}
}
])
// requiredSkills: ["mongo", "node"]
// candidateSkills: ["mongo", "node", "react"]
// meetsRequirements: true
// candidateSkills: ["mongo"]
// meetsRequirements: false (missing "node")Order matters for which array is the subset. Required skills must all appear in the candidate’s skill list.
Ensure every article tag is on the approved list:
db.articles.aggregate([
{
$project: {
title: 1,
tagsValid: {
$setIsSubset: [
"$tags",
"$approvedTags"
]
}
}
}
])
// tags: ["mongodb", "tutorial"]
// approvedTags: ["mongodb", "tutorial", "news"]
// tagsValid: trueUseful for content moderation: reject or flag articles where any tag falls outside the whitelist.
Keep only applications where the candidate meets all skill requirements:
db.applications.aggregate([
{
$match: {
$expr: {
$setIsSubset: [
"$requiredSkills",
"$candidateSkills"
]
}
}
},
{
$project: { candidate: 1, jobTitle: 1 }
}
])Wrap $setIsSubset in $expr inside $match to filter documents at query time.
Assign a readable compliance label from the subset check:
db.users.aggregate([
{
$project: {
name: 1,
status: {
$cond: [
{
$setIsSubset: [
"$roles",
"$allowedRoles"
]
},
"compliant",
"invalid roles"
]
}
}
}
])Combine with $cond for audit reports and admin dashboards that need human-readable status text.
$setIsSubset WorksBoth arguments resolve to arrays (field paths, literals, or nested expressions).
Duplicates are ignored and order does not matter for either array.
If any value in the first array is missing from the second, the result is false.
Use in projections, filters, or conditional logic.
The $setIsSubset operator checks whether the first array is contained in the second using set semantics. It returns true when every element of array1 appears in array2.
Use it for role validation, skill requirements, and tag whitelists. Remember argument order: put the smaller or required set first. Next in the series: $setUnion.
$setIsSubset for “has all of” checks$expr when filtering with $match$ifNull to treat missing arrays as [] when appropriate$setEquals when both arrays must be exactly the same set[B, A] is not the same as [A, B][] as the first array always returns true$setIntersection when you only need a boolean answer$setIsSubsetUse these points when checking whether one array is contained in another.
Contained in B.
PurposeExactly two.
SyntaxFirst ⊆ second.
RuleAlways true.
Edge caseSubset vs equal.
CompareMove on to $setUnion to combine unique elements from multiple arrays, or review $setIntersection.
5 people found this page helpful