Cardinal $ins: MongoDB Query Performance Over Ranges

db.drivers.find({"country": {"$in": ["A", "G"]}).sort({"carsOwned": 1})

{"country": 1, "carsOwned": 1}

Now, back to the question. Given indexing basics, conventional wisdom says that for the following query:

db.collection.find({"country": "A"}).sort({"carsOwned": 1})

We should create the following index:

db.collection.ensureIndex({"country": 1, "carsOwned": 1})

What if most queries to these fields are “range” checks instead of “equivalency” checks? As in:

db.collection.find({"country": {"$in": ["A", "G"]}}).sort({"carsOwned": 1})

We use $in here, but this applies to all range operators: $gt, $lt, etc.

If you see queries like this performing poorly, and you remember your basics, you’ll run a .explain() and see that see the index is being used. But you will also see {scanAndOrder : true}, revealing that MongoDB has performed an ordering operation. Here’s where the cost is. scanAndOrder is expensive because it sorts documents in memory. It should be avoided for large result sets because it’s slower and more CPU-intensive.

But forget about why scanAndOrder is slow; why would MongoDB order results if we’ve already accounted for the order in our index? Easy: We haven’t.

Why? The reason is simple and has to do with the structure of the index we created. For the example above, the documents having {“country”: “A”} and the documents having {“country”: “G”} are sorted–in the index–by {“carsOwned”: 1}, but they are sorted independently from each other. They’re not sorted together! Consider the diagram below:

The left-hand side of the diagram below shows the order thatMongoDB visits documents as it crawls the index we created. After documents matching all the criteria are found, the results must be ordered. The right-hand side shows an alternative index: { “carsOwned”: 1, “country”: 1}. By shifting the consideration of the sort field forward (leftward) in the index, we create a scenario where MongoDB visits the documents in the order we will ask for them. This subtle point of efficiency has led to the following rule of thumb when indexing:

The order of fields in an index should be:

1. First, fields on which you will query for exact values.
2. Second, fields on which you will sort.
3. Finally, fields on which you will query for a range of values.

Is there a trade-off? Yes. The query will visit more index nodes than it technically needs to, because traversal of the sort portion of the index will occur before pruning by the range criteria (“country”, in the example”). So, while we’ve seen this new rule of thumb as a net benefit for many queries, be aware that the cardinality of your data may yield different results.

I hope this guidance is helpful for you. Good luck out there, adventurers!

Sincerely,
Eric@MongoLab