Getting only documents that meet a criteria based on values in a field containing an array of objects - mongodb

Question

I have documents like this:
{
name: 'john',
array: [{foo: 3, bar: 1},{foo:1, bar: 0},...]
}
I would like to find all the documents that have a difference between foo and bar smaller than some value in one of the entries in the array. I am currently trying to use the $where query. I get back an empty list. Is my issue with the way I am using promises or with the way I am using $where?
Code:
MongoClient.connect(config.database)
.then(function(db) {
return db.collection('MyCollection')
})
.then(function (collection) {
return collection.find(
{ $where:
function() {
for(var i = 0; i < this.array.length; i++) {
if((this.array[i].foo - this.array[i].bar) < 2) {
return true;
}
}
return false;
}
}
)
})
.then(function(cursor) {
return cursor.toArray()
})
.then(function(arr) {
console.log(arr)
})
.catch(function(err) {
throw err;
});

Answer 1

Using the aggregation framework with the $redact pipeline operator allows you to proccess the logical condition with the $cond operator and uses the special operations $$KEEP to "keep" the document where the logical condition is true or $$PRUNE to "remove" the document where the condition was false.
This operation is similar to having a $project pipeline that selects the fields in the collection and creates a new field that holds the result from the logical condition query and then a subsequent $match, except that $redact uses a single pipeline stage which is more efficient.
Consider the following example which demonstrate the above concept:
db.collection.aggregate([
{
"$redact": {
"$cond": [
{
"$anyElementTrue": {
"$map": {
"input": "$array",
"as": "el",
"in": {
"$lt": [
{ "$subtract": ["$$el.foo", "$$el.bar"] },
2
]
}
}
}
},
"$$KEEP",
"$$PRUNE"
]
}
}
])
In the above example, the $anyElementTrue and $map combo works in such a way that if any of the elements in the array actually had the difference between its foo and bar values less than 2, then this is a true match and the document is "kept". Otherwise it is "pruned" and discarded.
As a result, your refactored code should look like
MongoClient.connect(config.database)
.then(function(db) {
return db.collection('MyCollection')
})
.then(function (collection) {
return collection.aggregate([
{
"$redact": {
"$cond": [
{
"$anyElementTrue": {
"$map": {
"input": "$array",
"as": "el",
"in": {
"$lt": [
{ "$subtract": ["$$el.foo", "$$el.bar"] },
2
]
}
}
}
},
"$$KEEP",
"$$PRUNE"
]
}
}
]);
})
.then(function(cursor) {
return cursor.toArray()
})
.then(function(arr) {
console.log(arr)
})
.catch(function(err) {
throw err;
});
and this should improve in performance significantly because the $redact operator uses MongoDB's native operators whilst a query operation with the $where operator calls the JavaScript engine to evaluate Javascript code on every document and checks the condition for each.
This is very slow as MongoDB evaluates non-$where query operations before $where expressions and non-$where query statements may use an index.
It is advisable to combine with indexed queries if you can so that the query may be faster. However, it's recommended to use JavaScript expressions and the $where operator as a last resort when you can't structure the data in any other way, or when you are dealing with a small subset of data.