How to use $elemMatch on aggregate's projection?

Question

This is my object:

{ \"_id\" : ObjectId(\"53fdcb6796cb9b9aa86f05b9\"), \"list\" : [ \"a\", \"b\" ], \"complist\" : [ { \"a\" : \"a\", \"b\" : \"b\" }, { \"a\         


        

Answer 1

Although the question is old, here is my contribution for November 2017.

I had similar problem and doing two consecutive match operations worked for me. The code below is a subset of my whole code and I changed elements names, so it's not tested. Anyway this should point you in the right direction.

db.collection.aggregate([
    {
        "$match": {
            "_id": "ID1"
        }
    },
    {
        "$unwind": "$sub_collection"
    },
    {
        "$match": {
            "sub_collection.field_I_want_to_match": "value"
        }
    }
])

Answer 2

Well, it happens you can use "array.field" on a find's projection block.

 db.itens.find({},{"complist.b":1,list:{$elemMatch:{$in:["a"]}}})

did what I needed.

Answer 3

Quite on old question but literally none of the proposed answers are good.

---

TLDR:

You can't use $elemMatch in a $project stage. but you can achieve the same result using other aggregation operators like $filter.

db.itens.aggregate([
    {
        $project: {
            compList: {
               $filter: {
                input: "$complist",
                as: "item",
                cond: {$eq: ["$$item.a", 1]}
               }
            }
        }
    }
])

And if you want just the first item from the array that matches the condition similarly to what $elemMatch does you can incorporate $arrayElemAt

---

In Depth Explanation:

First let's understand $elemMatch:

$elemMatch is a query expressions while also this projection version of it exists this refers to a query projection and not $project aggregation stage.

So what? what does this have to do with anything? well a $project stage has certain input structure it can have while the one we want to use is:

<field>: <expression>

What is a valid expression?

Expressions can include field paths, literals, system variables, expression objects, and expression operators. Expressions can be nested.

So we want to use an expression operator, but as you can see from the doc's $elemMatch is not part of it. hence it's not a valid expression to be used in an aggregation $project stage.

Answer 4

The answer to this question maybe help.

db.collection_name.aggregate({
    "$match": {
        "complist": {
            "$elemMatch": {
                "a": "a"
            }
        }
    }
});

Answer 5

Actually, the simplest solution is to just $unwind your array, then $match the appropriate documents. You can wind-up the appropriate documents again using $group and $push.

Answer 6

You can use $eq operator with $elemMatch

db.items.find({}, {
  "complist.b": 1,
  "list": { $elemMatch: { $eq: "a" } }
})