Find Documents by the number of embedded array elements that match condition - mongodb

Question

I am new to MongoDB and need help in accomplishing my task:
I am using MongoDB to query for actions that were taken by a person. The actions are embedded in the person document like this:
{
"_id" : ObjectId("56447ac0583d4871570041c3"),
"email" : "email#example.net",
"actions" : [
{
"name" : "support",
"created_at" : ISODate("2015-10-17T01:40:35.000Z"),
},
{
"name" : "hide",
"created_at" : ISODate("2015-10-16T01:40:35.000Z")
},
{
"name" : "support",
"created_at" : ISODate("2015-10-17T03:40:35.000Z"),
}
]
}
A person can have many actions with different action names (support and hide are just 2 examples).
I know that I could find all people with at least one support action like this:
db.test.find({'actions.name':'support'})
What I want to do, is, retrieve all people with at least X support actions. Is this possible without using javascript syntax? As people could have hundreds of actions, this would be slow.
So, If I want all people with at least 2 support actions, the only way I know would be using the js syntax:
db.test.find({$where: function() {
return this.actions.filter(function(action){
return action.name = 'support';
}).length >= 2;
}});
Is there an other/better/faster possibility for this query?

Answer 1

Well the best way to do this is using the the .aggregate() method which provides access to the aggregation pipelines.
You can reduce the size of documents to process on the pipeline using $match operator to filter out all documents that don't match the given criteria.
You need to use the $redact operator to return only documents where the numbers of elements that with name "support" in your array is $gte 2. The $map operator here return an array of subdocuments that match your critera and false that you can easily drop using the $setDifference operator. Of course the $size operator returns the size of the array.
db.test.aggregate([
{ "$match": {
"actions.name": "support",
"actions.2": { "$exists": true }
}},
{ "$redact": {
"$cond": [
{ "$gte": [
{ "$size": {
"$setDifference": [
{ "$map": {
"input": "$actions",
"as": "action",
"in": {
"$cond": [
{ "$eq": [ "$$action.name", "support" ] },
"$$action",
false
]
}
}},
[false]
]
}},
2
]},
"$$KEEP",
"$$PRUNE"
]
}}
])
From MongoDB 3.2 this can be handled using the $filter operator.
db.test.aggregate([
{ "$match": {
"actions.name": "support",
"actions.2": { "$exists": true }
}},
{ "$redact": {
"$cond": [
{ "$gte": [
{ "$size": {
"$filter": {
"input": "$actions",
"as": "action",
"cond": { "$eq": [ "$$action.name", "support" ] }
}
}},
2
]},
"$$KEEP",
"$$PRUNE"
]
}}
])
As #BlakesSeven pointed out:
$setDifference is fine as long as the data being filtered is "unique". In this case it "should" be fine, but if any two results contained the same date then it would skew results by considering the two to be one. $filter is the better option when it comes, but if data was not unique it would be necessary to $unwind at present.

Answer 2

I haven't benchmarked this against your attempt, but this sounds like a great usecase for Mongo's aggregation framework.
db.test.aggregate([
{$unwind: "$actions"},
{$group: {
_id: { _id: "$_id", action: "$actions},
count: {$sum: 1}
},
{$match: {$and: [{count: {$gt: 2}}, {"_id.action": "support"]}
]);
Note that I havent run this in mongo, so it might have some syntax issues.
The idea behind it is:
unwind the actions array so each element of the array becomes its own document
group the resulting collection by an _id - action type pair, and count how much we get of each.
match will filter for only things we are interested in.