MongoDB $setIsSubset Operator

What Is $setIsSubset?

$setIsSubset is a MongoDB aggregation expression that returns true when the first array is a subset of the second—every unique value in A also appears in B. Order and duplicates are ignored. Equal arrays also return true.

$setIsSubset = is A ⊆ B ?

{ $setIsSubset: [ <arrayA>, <arrayB> ] }

{ $setIsSubset: [ [1, 2], [1, 2, 3] ] }     → true
{ $setIsSubset: [ [1, 2], [1, 3] ] }        → false
{ $setIsSubset: [ [1, 2, 1], [2, 1] ] }     → true  (dupes ignored)
{ $setIsSubset: [ [], [1, 2] ] }            → true  (empty ⊆ any)

equal arrays → true (a set is a subset of itself)
nested arrays compared as whole elements

How to Use $setIsSubset in MongoDB

Pass two arrays: the candidate subset first, the larger set second.

1. Choose an expression stage ($addFields or $project).
2. Write { $setIsSubset: [ "$required", "$tags" ] } (A first, B second).
3. Read the boolean: true means every required value is present in tags.
4. To filter documents, use $match with $expr.

Pseudocode

for each document:
    A = unique values of first array
    B = unique values of second array
    result = true
    for each value in A:
        if value not in B:
            result = false
            break
    emit { ..., field: result }

Cheat Sheet

Keep these facts handy while checking array subsets.

Live Preview

Watch $setIsSubset test whether array A is contained in array B.

A = ["read", "write"]
B = ["read", "write", "admin"]

$setIsSubset → true

{ ok: true }

Worked Walkthrough — Required Permissions

A role needs ["read", "write"]. A user has ["read", "write", "admin"]. Is the requirement a subset?

A (required) = [ "read", "write" ]
B (tags)     = [ "read", "write", "admin" ]

Check each value in A:
  "read"  in B? → yes
  "write" in B? → yes

$setIsSubset → true

If A were [ "read", "delete" ]:
  "delete" in B? → no → false

MongoDB Examples

We use two users with required permissions and tags. First we store them, then we compute the subset flag, then we filter to users who meet the requirement. Run these in mongosh after inserting the sample data once.

db.users.insertMany([
  {
    _id: 1,
    name: "Asha",
    required: ["read", "write"],
    tags: ["read", "write", "admin"]
  },
  {
    _id: 2,
    name: "Ben",
    required: ["read", "delete"],
    tags: ["read", "write"]
  }
]);

db.users.find()

[
  {
    _id: 1,
    name: "Asha",
    required: ["read", "write"],
    tags: ["read", "write", "admin"]
  },
  {
    _id: 2,
    name: "Ben",
    required: ["read", "delete"],
    tags: ["read", "write"]
  }
]

Asha:
  required  ⊆  tags ?
  {read, write} ⊆ {read, write, admin}  →  true

Ben:
  required  ⊆  tags ?
  {read, delete} ⊆ {read, write}       →  false
  (missing "delete")

db.users.aggregate([
  {
    $addFields: {
      ok: {
        $setIsSubset: ["$required", "$tags"]
      }
    }
  }
]);

[
  {
    _id: 1,
    name: "Asha",
    required: ["read", "write"],
    tags: ["read", "write", "admin"],
    ok: true
  },
  {
    _id: 2,
    name: "Ben",
    required: ["read", "delete"],
    tags: ["read", "write"],
    ok: false
  }
]

db.users.aggregate([
  {
    $match: {
      $expr: {
        $setIsSubset: ["$required", "$tags"]
      }
    }
  },
  {
    $project: {
      name: 1,
      required: 1,
      tags: 1
    }
  }
]);

{
  _id: 1,
  name: "Asha",
  required: ["read", "write"],
  tags: ["read", "write", "admin"]
}

Performance Notes

Subset checks on typical tag/role arrays are inexpensive compared with large sorts or joins. Filter early with $match when only some documents need the check.

Key Takeaways