MongoDB $strcasecmp Operator

What You’ll Learn

The $strcasecmp operator compares two strings without regard to letter case. It returns 0 when they match, -1 when the first is less, and 1 when the first is greater — ideal for case-insensitive filtering and validation.

Definition and Usage

In MongoDB’s aggregation framework, the $strcasecmp operator performs a case-insensitive comparison of two strings. For example, { $strcasecmp: [ "Active", "active" ] } returns 0 because the strings are equal when case is ignored.

Use it when user input or stored data may vary in capitalization — such as status fields ("Pending" vs "pending"), role names, or email local parts. Pair it with $eq to test equality, or with $cond for conditional logic.

📝 Syntax

The $strcasecmp operator takes an array of two string expressions:

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

Return Values

{ $strcasecmp: [ "Active", "active" ] }
// Result: 0  (equal, case ignored)

{ $strcasecmp: [ "apple", "banana" ] }
// Result: -1  (apple comes before banana)

{ $strcasecmp: [ "zebra", "apple" ] }
// Result: 1   (zebra comes after apple)

Syntax Rules

• First argument — string expression (field path or literal).
• Second argument — string expression to compare against.
• Returns 0 — strings are equal (case-insensitive).
• Returns -1 — first string is lexicographically less.
• Returns 1 — first string is lexicographically greater.
• Use inside $project, $addFields, $match with $expr, or find queries with $expr.

Examples Gallery

Compare strings in aggregation pipelines, filter documents case-insensitively, and build conditional logic from comparison results.

[
  { "_id": 1, "name": "Alice", "status": "Active" },
  { "_id": 2, "name": "Bob",   "status": "inactive" },
  { "_id": 3, "name": "Carol", "status": "ACTIVE" },
  { "_id": 4, "name": "Dave",  "status": "Pending" }
]

db.users.aggregate([
  {
    $project: {
      name: 1,
      status: 1,
      compareResult: {
        $strcasecmp: [ "$status", "active" ]
      }
    }
  }
])

// Alice: status "Active"  → compareResult: 0  (match)
// Bob:   status "inactive" → compareResult: -1 (before "active")
// Carol: status "ACTIVE"   → compareResult: 0  (match)
// Dave:  status "Pending"  → compareResult: 1  (after "active")

db.users.aggregate([
  {
    $match: {
      $expr: {
        $eq: [
          { $strcasecmp: [ "$status", "active" ] },
          0
        ]
      }
    }
  },
  {
    $project: { name: 1, status: 1 }
  }
])

// Matches: Alice ("Active"), Carol ("ACTIVE")
// Excludes: Bob ("inactive"), Dave ("Pending")

db.users.find({
  $expr: {
    $eq: [
      { $strcasecmp: [ "$role", "admin" ] },
      0
    ]
  }
})

// Matches role: "admin", "Admin", "ADMIN", etc.

db.users.aggregate([
  {
    $addFields: {
      isActive: {
        $eq: [
          { $strcasecmp: [ "$status", "active" ] },
          0
        ]
      }
    }
  }
])

// "Active"  → isActive: true
// "ACTIVE"  → isActive: true
// "Pending" → isActive: false

db.users.aggregate([
  {
    $project: {
      email: 1,
      emailConfirm: 1,
      emailsMatch: {
        $eq: [
          { $strcasecmp: [ "$email", "$emailConfirm" ] },
          0
        ]
      }
    }
  }
])

🚀 Use Cases

• Status and role filtering — match "active", "admin", or other enums regardless of stored casing.
• User input validation — compare form submissions to stored values without forcing lowercase on every write.
• Duplicate detection — find records where two string fields should match case-insensitively.
• Reporting flags — add computed booleans like isActive or isPremium in pipelines.

💡 Best Practices