UPDATE:

The original answer is now obsolete. Mongodb now supports advanced full text searching, with many features.

ORIGINAL ANSWER:

It should be noted that searching with regex's case insensitive /i means that mongodb cannot search by index, so queries against large datasets can take a long time.

Even with small datasets, it's not very efficient. You take a far bigger cpu hit than your query warrants, which could become an issue if you are trying to achieve scale.

As an alternative, you can store an uppercase copy and search against that. For instance, I have a User table that has a username which is mixed case, but the id is an uppercase copy of the username. This ensures case-sensitive duplication is impossible (having both "Foo" and "foo" will not be allowed), and I can search by id = username.toUpperCase() to get a case-insensitive search for username.

If your field is large, such as a message body, duplicating data is probably not a good option. I believe using an extraneous indexer like Apache Lucene is the best option in that case.

Keep in mind that the previous example:

db.stuff.find( { foo: /bar/i } );

will cause every entries containing bar to match the query ( bar1, barxyz, openbar ), it could be very dangerous for a username search on a auth function ...

You may need to make it match only the search term by using the appropriate regexp syntax as:

db.stuff.find( { foo: /^bar$/i } );

See http://www.regular-expressions.info/ for syntax help on regular expressions

If you need to create the regexp from a variable, this is a much better way to do it: https://stackoverflow.com/a/10728069/309514

You can then do something like:

var string = "SomeStringToFind";

var regex = new RegExp(["^", string, "$"].join(""), "i");

// Creates a regex of: /^SomeStringToFind$/i

db.stuff.find( { foo: regex } );

This has the benefit be being more programmatic or you can get a performance boost by compiling it ahead of time if you're reusing it a lot.

As of Mongodb 3.4 you should use a case-insensitive collation index. This is the fastest way to do a case-insensitive search over datasets of increasingly large size. I personally emailed one of the founders to please get this working, and he made it happen! (It was an issue on JIRA for like 5 years, and many have requested the feature). Here's how it works:

A case-insensitive index is made by specifying a collation with a strength of either 1 or 2. You can create a case-insensitive index like this:

db.myCollection.createIndex({city: 1}, {collation: {locale: "en", strength: 2}});

Or you can do it for the whole collection by default when you create the database like so:

db.createCollection("Cities",{collation: {locale: "en",strength:2}});

And use it like this:

db.myCollection.find({city: "new york"}).collation({locale: "en", strength: 2});

This will return "New York", "new york", etc.

Alternatively, you can make all indexes use a collation by default when you make the collection like this:

db.createCollection("cities",{collation:{locale: "en", strength: 2}});

The benefit to this method is much improved efficiency and speed on larger datasets.

For more info: https://jira.mongodb.org/browse/SERVER-90 , https://docs.mongodb.com/manual/reference/collation/

db.zipcodes.find({city : "NEW YORK"}); // Case-sensitive

db.zipcodes.find({city : /NEW york/i}); // Note the 'i' flag for case-insensitivity

TL;DR

Correct way to do this in mongo

Do not Use RegExp

Go natural And use mongodb's inbuilt indexing , search

Step 1 :

db.articles.insert(

   [

     { _id: 1, subject: "coffee", author: "xyz", views: 50 },

     { _id: 2, subject: "Coffee Shopping", author: "efg", views: 5 },

     { _id: 3, subject: "Baking a cake", author: "abc", views: 90  },

     { _id: 4, subject: "baking", author: "xyz", views: 100 },

     { _id: 5, subject: "Café Con Leche", author: "abc", views: 200 },

     { _id: 6, subject: "Сырники", author: "jkl", views: 80 },

     { _id: 7, subject: "coffee and cream", author: "efg", views: 10 },

     { _id: 8, subject: "Cafe con Leche", author: "xyz", views: 10 }

   ]

)

Step 2 :

Need to create index on whichever TEXT field you want to search , without indexing query will be extremely slow

db.articles.createIndex( { subject: "text" } )

step 3 :

db.articles.find( { $text: { $search: "coffee",$caseSensitive :true } } )  //FOR SENSITIVITY

db.articles.find( { $text: { $search: "coffee",$caseSensitive :false } } ) //FOR INSENSITIVITY

Mongo (current version 2.0.0) doesn't allow case-insensitive searches against indexed fields - see their documentation. For non-indexed fields, the regexes listed in the other answers should be fine.

Using Mongoose this worked for me:

var find = function(username, next){

    User.find({'username': {$regex: new RegExp('^' + username, 'i')}}, function(err, res){

        if(err) throw err;

        next(null, res);

    });

}

The best method is in your language of choice, when creating a model wrapper for your objects, have your save() method iterate through a set of fields that you will be searching on that are also indexed; those set of fields should have lowercase counterparts that are then used for searching.

Every time the object is saved again, the lowercase properties are then checked and updated with any changes to the main properties. This will make it so you can search efficiently, but hide the extra work needed to update the lc fields each time.

The lower case fields could be a key:value object store or just the field name with a prefixed lc_. I use the second one to simplify querying (deep object querying can be confusing at times).

Note: you want to index the lc_ fields, not the main fields they are based off of.

Suppose you want to search "column" in "Table" and you want case insenstive search. The best and efficient way is as below;

//create empty JSON Object

mycolumn = {};



//check if column has valid value

if(column) {

    mycolumn.column = {$regex: new RegExp(column), $options: "i"};

}

Table.find(mycolumn);

Above code just adds your search value as RegEx and searches in with insensitve criteria set with "i" as option.

All the best.

One very important thing to keep in mind when using a Regex based query - When you are doing this for a login system, escape every single character you are searching for, and don't forget the ^ and $ operators. Lodash has a nice function for this, should you be using it already:

db.stuff.find({$regex: new RegExp(_.escapeRegExp(bar), $options: 'i'})

Why? Imagine a user entering .* as his username. That would match all usernames, enabling a login by just guessing any user's password.

db.company_profile.find({ "companyName" : { "$regex" : "Nilesh" , "$options" : "i"}});

The aggregation framework was introduced in mongodb 2.2 . You can use the string operator "$strcasecmp" to make a case-insensitive comparison between strings. It's more recommended and easier than using regex.

Here's the official document on the aggregation command operator: https://docs.mongodb.com/manual/reference/operator/aggregation/strcasecmp/#exp._S_strcasecmp .

Using a filter works for me in C#.

string s = "searchTerm";

    var filter = Builders<Model>.Filter.Where(p => p.Title.ToLower().Contains(s.ToLower()));

                var listSorted = collection.Find(filter).ToList();

                var list = collection.Find(filter).ToList();

It may even use the index because I believe the methods are called after the return happens but I haven't tested this out yet.

This also avoids a problem of

var filter = Builders<Model>.Filter.Eq(p => p.Title.ToLower(), s.ToLower());

that mongodb will think p.Title.ToLower() is a property and won't map properly.

You can use Case Insensitive Indexes:

The following example creates a collection with no default collation, then adds an index on the name field with a case insensitive collation. International Components for Unicode

/* strength: CollationStrength.Secondary

* Secondary level of comparison. Collation performs comparisons up to secondary * differences, such as diacritics. That is, collation performs comparisons of 

* base characters (primary differences) and diacritics (secondary differences). * Differences between base characters takes precedence over secondary 

* differences.

*/

db.users.createIndex( { name: 1 }, collation: { locale: 'tr', strength: 2 } } )

To use the index, queries must specify the same collation.

db.users.insert( [ { name: "Oğuz" },

                            { name: "oğuz" },

                            { name: "OĞUZ" } ] )



// does not use index, finds one result

db.users.find( { name: "oğuz" } )



// uses the index, finds three results

db.users.find( { name: "oğuz" } ).collation( { locale: 'tr', strength: 2 } )



// does not use the index, finds three results (different strength)

db.users.find( { name: "oğuz" } ).collation( { locale: 'tr', strength: 1 } )

or you can create a collection with default collation:

db.createCollection("users", { collation: { locale: 'tr', strength: 2 } } )

db.users.createIndex( { name : 1 } ) // inherits the default collation

For searching a variable and escaping it:

const escapeStringRegexp = require('escape-string-regexp')

const name = 'foo'

db.stuff.find({name: new RegExp('^' + escapeStringRegexp(name) + '$', 'i')})   

Escaping the variable protects the query against attacks with '.*' or other regex.

escape-string-regexp

I've created a simple Func for the case insensitive regex, which I use in my filter.

private Func<string, BsonRegularExpression> CaseInsensitiveCompare = (field) => 

            BsonRegularExpression.Create(new Regex(field, RegexOptions.IgnoreCase));

Then you simply filter on a field as follows.

db.stuff.find({"foo": CaseInsensitiveCompare("bar")}).count();

As you can see in mongo docs - since version 3.2 $text index is case-insensitive by default: https://docs.mongodb.com/manual/core/index-text/#text-index-case-insensitivity

Create a text index and use $text operator in your query.

These have been tested for string searches

{'_id': /.*CM.*/}               ||find _id where _id contains   ->CM

{'_id': /^CM/}                  ||find _id where _id starts     ->CM

{'_id': /CM$/}                  ||find _id where _id ends       ->CM



{'_id': /.*UcM075237.*/i}       ||find _id where _id contains   ->UcM075237, ignore upper/lower case

{'_id': /^UcM075237/i}          ||find _id where _id starts     ->UcM075237, ignore upper/lower case

{'_id': /UcM075237$/i}          ||find _id where _id ends       ->UcM075237, ignore upper/lower case

I had faced a similar issue and this is what worked for me:

  const flavorExists = await Flavors.findOne({

    'flavor.name': { $regex: flavorName, $options: 'i' },

  });

Use RegExp,
In case if any other options do not work for you, RegExp is a good option. It makes the string case sensitive.

var username = "John";



var uname = new RegExp(username, "i");

The value of uname will be like /John/i.

use uname in queries instead of username,
and then its done.

I hope it will work for you too. All the Best.