$regex

$in Expressions

To include a regular expression in an $in query expression, you can only use JavaScript regular expression objects (i.e. /pattern/ ). For example:

{ name: { $in: [ /^acme/i, /^ack/ ] } }

You cannot use $regex operator expressions inside an $in operator.

Implicit AND Conditions for the Field

To include a regular expression in a comma-separated list of query conditions for the field, use the $regex operator. For example:

{ name: { $regex: /acme.*corp/i, $nin: [ 'acmeblahcorp' ] } }
{ name: { $regex: /acme.*corp/, $options: 'i', $nin: [ 'acmeblahcorp' ] } }
{ name: { $regex: 'acme.*corp', $options: 'i', $nin: [ 'acmeblahcorp' ] } }

x and s Options

To use either the x option or s options, you must use the $regex operator expression with the $options operator. For example, to specify the i and the s options, you must use $options for both:

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

PCRE vs JavaScript

To use PCRE supported features in a regular expression that aren't supported in JavaScript, you must use the $regex operator and specify the regular expression as a string.

To match case-insensitive strings:

• "(?i)" begins a case-insensitive match.

• "(?-i)" ends a case-insensitive match.

For example, the regular expression "(?i)a(?-i)cme" matches strings that:

• Begin with "a" or "A". This is a case-insensitive match.

• End with "cme". This is a case-sensitive match.

These strings match the example regular expression:

• "acme"

• "Acme"

The following example uses the $regex operator to find name field strings that match the regular expression "(?i)a(?-i)cme":

{ name: { $regex: "(?i)a(?-i)cme" } }

$regex and $not

The $not operator can perform logical NOT operation on both:

• Regular expression objects (i.e. /pattern/)

  For example:

  db.inventory.find( { item: { $not: /^p.*/ } } )

• $regex operator expressions

  For example:

  db.inventory.find( { item: { $not: { $regex: "^p.*" } } } )
  db.inventory.find( { item: { $not: { $regex: /^p.*/ } } } )

In 4.0.6 and earlier, you could use $not operator with regular expression objects (i.e. /pattern/) but not with $regex operator expressions.

Case-Sensitive Queries

For case sensitive regular expression queries, if an index exists for the field, then MongoDB matches the regular expression against the values in the index, which can be faster than a collection scan.

Further optimization can occur if the regular expression is a "prefix expression", which means that all potential matches start with the same string. This allows MongoDB to construct a "range" from that prefix and only match against those values from the index that fall within that range.

A regular expression is a "prefix expression" if it starts with a caret (^) or a left anchor (\A), followed by a string of simple symbols. For example, the regex /^abc.*/ will be optimized by matching only against the values from the index that start with abc.

Additionally, while /^a/, /^a.*/, and /^a.*$/ match equivalent strings, they have different performance characteristics. All of these expressions use an index if an appropriate index exists; however, /^a.*/, and /^a.*$/ are slower. /^a/ can stop scanning after matching the prefix.

Case-Insensitive Queries

Case-insensitive indexes typically do not improve performance for $regex queries. The $regex implementation is not collation-aware and cannot utilize case-insensitive indexes efficiently.