Spring Data Mongo - Perform Regular Search? - mongodb

Question

I went through many links like this: How to create full text search query in mongodb with spring-data?, but did not get the correct approach.
I've an Employee collection which holds 1000 documents. I want to give capability to perform search ignorecase where when I search for ra, I should get Ravi,Ram, rasika etc names.
I used below logic which works fine, but I wanted to understand from the perspective of performance. Is there any better solution than this?
Query query = new Query(Criteria.where("employeeName").regex("^"+employeeName, "i"));

Answer 1

You can create an index on the field you are applying the query filter using the regular expression. For example, consider the documents in a person collection:
{ "name" : "ravi" }
{ "name" : "ram" }
{ "name" : "John" }
{ "name" : "renu" }
{ "name" : "Raj" }
{ "name" : "peter" }
The following query (run from Mongo Shell) finds and fetches the four documents with the names starting with the letter "r" or "R":
db.person.find( { name: { $regex: "^r", $options: "i" } } )
But, the query performs a collection scan, without an index on the name field. So, create an index on the field.
db.person.createIndex( { name: 1 } )
Now, run the query and generate a query plan for the same query (using the explain()). The query plan shown that it is an IXSCAN (an indexed scan). And, this will be an efficiently performing query.
Note that prefix searches (as in the above query using the ^) on index fields results in faster performing queries.
From the documentation:
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.
Though the documentation says the following (see below paragraph), the query I ran did use the index and the query plan generated using the explain() showed an index scan.
Case insensitive regular expression queries generally cannot use
indexes effectively. The $regex implementation is not collation-aware
and is unable to utilize case-insensitive indexes.