Counting similar items in array with mongodb aggregation framework - mongodb

Question

I'm just learning mongodb aggregation framework
There are data in the the format below:
{
"questionType": "multiple",
"multipleOptions": ["first", "second", "third", "forth"],
"answers": ["first", "second", "second", "first", "first", "forth"]
},
{
"questionType": "multiple",
"multipleOptions": ["awful", "bad", "soso", "good", "excellent"],
"answers": ["bad", "bad", "good", "soso", "bad", "excellent", "awful", "soso"]
}
I want to aggregate these to something like this:
{
"result": { "first": 3, "second": 2, "forth": 1 }
},
{
"result": { "awful": 1, "bad": 3, "soso": 2, "good": 1, "excellent": 1 }
}
Or like this (no difference):
{
"result": [["first", 3], ["second", 2], ["forth", 1]]
},
{
"result": [["awful", 1], ["bad", 3], ["soso", 2], ["good", 1], ["excellent", 1]]
}
Is there a way to do this in a $project stage?

Answer 1

This can be done with a cohort of array operators working in conjunction to produce the desired effect.
You essentially need an operation that creates an array of key/value pairs of the counts you need. This will then be converted to a hash map. The array of key value pairs is essentially a map which is constructed by looping through the multipleOptions array and checking the size of the elements that match in the answers array.
TLDR;
The final pipeline you need to run follows:
db.collection.aggregate([
{ "$project": {
"result": {
"$arrayToObject": {
"$map": {
"input": { "$range": [ 0, { "$size": "$multipleOptions" } ] },
"as": "idx",
"in": {
"$let": {
"vars": {
"k": {
"$arrayElemAt": [
"$multipleOptions",
"$$idx"
]
},
"v": {
"$size": {
"$filter": {
"input": "$answers",
"as": "ans",
"cond": {
"$eq": [
"$$ans",
{
"$arrayElemAt": [
"$multipleOptions",
"$$idx"
]
}
]
}
}
}
}
},
"in": { "k": "$$k", "v": "$$v" }
}
}
}
}
}
} }
])
To demonstrate this step by step, lets create an additional field in an aggregate operation, this field will be an array of the
counts of the corresponding array element. We need something like
{
"questionType": "multiple",
"multipleOptions": ["awful", "bad", "soso", "good", "excellent"],
"answersCount": [1, 3, 2, 1, 1],
"answers": ["bad", "bad", "good", "soso", "bad", "excellent", "awful", "soso"]
}
To get this we need a way to loop through the multipleOptions and for each option, iterate the answers array, filter it and count the number of elements in the filtered array. The pseudo-algorithm follows:
answersCount = []
for each elem in ["awful", "bad", "soso", "good", "excellent"]:
filteredAnswers = [<answers array containing only elem>]
count = filteredAnswers.length
answersCount.push(count)
In mongo, the filtering part can be done using $filter on the answers array and elements can be referenced with $arrayElemAt
{
"$filter": {
"input": "$answers",
"as": "ans",
"cond": {
"$eq": [
"$$ans",
{ "$arrayElemAt": [ "$multipleOptions", "$$idx" ] }
]
}
}
}
The counts are derived using $size on the above expression
{
"$size": {
"$filter": {
"input": "$answers",
"as": "ans",
"cond": {
"$eq": [
"$$ans",
{ "$arrayElemAt": [ "$multipleOptions", "$$idx" ] }
]
}
}
}
}
For getting the outer loop, we can use $range and $map as
{
"$map": {
"input": { "$range": [ 0, { "$size": "$multipleOptions" } ] },
"as": "idx",
"in": {
"$let": {
"vars": {
"v": {
"$size": {
"$filter": {
"input": "$answers",
"as": "ans",
"cond": {
"$eq": [
"$$ans",
{ "$arrayElemAt": [ "$multipleOptions", "$$idx" ] }
]
}
}
}
}
},
"in": "$$v"
}
}
}
}
This will produce the answersCount in the following aggregate operation
db.collection.aggregate([
{ "$addFields": {
"answersCount": {
"$map": {
"input": { "$range": [ 0, { "$size": "$multipleOptions" } ] },
"as": "idx",
"in": {
"$let": {
"vars": {
"v": {
"$size": {
"$filter": {
"input": "$answers",
"as": "ans",
"cond": {
"$eq": [
"$$ans",
{ "$arrayElemAt": [ "$multipleOptions", "$$idx" ] }
]
}
}
}
}
},
"in": "$$v"
}
}
}
}
} }
])
To then get to the desired output, you need the answersCount to be an array of key/value pairs i.e.
{
"answersCount": [
{ "k": "awful", "v": 1},
{ "k": "bad", "v": 3},
{ "k": "soso", "v": 2},
{ "k": "good", "v": 1},
{ "k": "excellent", "v": 1}
],
}
and when you apply $arrayToObject on the above expression i.e.
{ "$arrayToObject": {
"answersCount": [
{ "k": "awful", "v": 1},
{ "k": "bad", "v": 3},
{ "k": "soso", "v": 2},
{ "k": "good", "v": 1},
{ "k": "excellent", "v": 1}
],
} }
you get
{
"awful" : 1,
"bad" : 3,
"soso" : 2,
"excellent" : 1,
"good" : 1
}

Answer 2

This is a good use case for "multi-stage grouping." Let's begin with an $unwind of answers:
c = db.foo.aggregate([
{$unwind: "$answers"}
]);
{
"_id" : 0,
"questionType" : "multiple",
"multipleOptions" : [
"first",
"second",
"third",
"forth"
],
"answers" : "first"
}
{
"_id" : 0,
"questionType" : "multiple",
"multipleOptions" : [
"first",
"second",
"third",
"forth"
],
"answers" : "second"
}
{
"_id" : 0,
"questionType" : "multiple",
"multipleOptions" : [
"first",
"second",
"third",
"forth"
],
"answers" : "second"
}
// ...
Now we have answers and _id as peers ready to group:
db.foo.aggregate([
{$unwind: "$answers"}
,{$group: {_id: {Xid:"$_id", answer:"$answers"}, n:{$sum:1} }}
]);
{ "_id" : { "Xid" : 1, "answer" : "awful" }, "n" : 1 }
{ "_id" : { "Xid" : 1, "answer" : "excellent" }, "n" : 1 }
{ "_id" : { "Xid" : 1, "answer" : "soso" }, "n" : 2 }
{ "_id" : { "Xid" : 1, "answer" : "bad" }, "n" : 3 }
{ "_id" : { "Xid" : 0, "answer" : "forth" }, "n" : 1 }
Now we group again, this time by the _id.Xid and then use $push to construct the output array of results:
db.foo.aggregate([
{$unwind: "$answers"}
,{$group: {_id: {Xid:"$_id", answer:"$answers"}, n:{$sum:1} }}
,{$group: {_id: "$_id.Xid", result: {$push: {answer: "$_id.answer", n: "$n" }} }}
]);
{
"_id" : 0,
"result" : [
{
"answer" : "forth",
"n" : 1
},
{
"answer" : "second",
"n" : 2
},
{
"answer" : "first",
"n" : 3
}
]
}
{
"_id" : 1,
"result" : [
{
"answer" : "awful",
"n" : 1
},
{
"answer" : "excellent",
"n" : 1
},
{
"answer" : "soso",
"n" : 2
},
{
"answer" : "bad",
"n" : 3
},
{
"answer" : "good",
"n" : 1
}
]
}
So in spirit we have a solution but to really press the point, we will use the $arrayToObject function to turn the array of options from the values of the answer key to keys in their own right. To do so, we will name the $push object args k and v to properly drive the function:
db.foo.aggregate([
{$unwind: "$answers"}
,{$group: {_id: {Xid:"$_id", answer:"$answers"}, n:{$sum:1} }}
,{$group: {_id: "$_id.Xid", QQ: {$push: {k: "$_id.answer", v: "$n" }} }}
,{$project: {_id: true, result: {$arrayToObject: "$QQ"} }}
]);
which yields:
{ "_id" : 0, "result" : { "forth" : 1, "second" : 2, "first" : 3 } }
{
"_id" : 1,
"result" : {
"awful" : 1,
"excellent" : 1,
"soso" : 2,
"bad" : 3,
"good" : 1
}
}