MongoDB $strcasecmp Operator

What Is $strcasecmp?

$strcasecmp is a MongoDB aggregation expression that compares two strings without regard to letter case. It returns 0 (equal), -1 (first is less), or 1 (first is greater). Behavior is well-defined for ASCII.

$strcasecmp = case-insensitive string compare for aggregation

{ $strcasecmp: [ <string1>, <string2> ] }

"Active" vs "active" → 0   (equal, ignore case)
"apple"  vs "Banana" → -1  (a < b)
"Zoo"    vs "apple"  → 1   (z > a)

equal check → $eq([ $strcasecmp(...), 0 ])
case-sensitive → use $eq / $cmp instead

How to Use $strcasecmp in MongoDB

Compare two strings, then test the result against 0 when you only care about equality.

1. Choose an expression stage ($addFields, $project, or $match).
2. Pass two string expressions to $strcasecmp.
3. Read -1, 0, or 1 as less / equal / greater (case ignored).
4. For a boolean match, wrap with $eq: compare the result to 0.

Pseudocode

for each document:
    a = evaluate(string1)
    b = evaluate(string2)
    // case-insensitive ASCII compare
    if lower(a) < lower(b):
        result = -1
    else if lower(a) > lower(b):
        result = 1
    else:
        result = 0
    emit { ..., field: result }

Cheat Sheet

Keep these facts handy while writing case-insensitive comparisons.

Live Preview

Watch $strcasecmp compare two strings while ignoring case. Try equal, less, and greater pairs.

a = "Admin"
b = "admin"

$strcasecmp → 0  (equal, ignore case)

{ match: true }

Worked Walkthrough — Role Match

A user document stores role: "Admin". We want to know if that matches "admin" without caring about capital letters.

Document:
  { name: "Alice", role: "Admin" }

Compare:
  $strcasecmp(["$role", "admin"])

Ignore case:
  "admin" vs "admin" → equal

Result:
  0

Equal check:
  $eq([0, 0]) → true ✓

MongoDB Examples

We store two users with mixed-case roles. First we compare each role to "admin", then we build a boolean isAdmin flag. Run these in mongosh after inserting the sample data once.

db.users.insertMany([
  { _id: 1, name: "Alice", role: "Admin" },
  { _id: 2, name: "Bob", role: "editor" }
]);

db.users.find()

[
  { _id: 1, name: "Alice", role: "Admin" },
  { _id: 2, name: "Bob", role: "editor" }
]

Target: "admin"

Alice: "Admin"  → ignore case → match → 0
Bob:   "editor" → ignore case → not match → 1
                 (e comes after a)

db.users.aggregate([
  {
    $addFields: {
      cmp: {
        $strcasecmp: ["$role", "admin"]
      }
    }
  }
]);

{ _id: 1, name: "Alice", role: "Admin", cmp: 0 }
{ _id: 2, name: "Bob", role: "editor", cmp: 1 }

db.users.aggregate([
  {
    $addFields: {
      isAdmin: {
        $eq: [
          { $strcasecmp: ["$role", "admin"] },
          0
        ]
      }
    }
  }
]);

{ _id: 1, name: "Alice", role: "Admin", isAdmin: true }
{ _id: 2, name: "Bob", role: "editor", isAdmin: false }

Performance Notes

For frequent case-insensitive lookups, a stored lowercase field (or collation) often beats scanning with $expr. Filter early with $match when only some documents need the check.

Key Takeaways