442

假设您在我的收藏中有以下文档：

{  
   "_id":ObjectId("562e7c594c12942f08fe4192"),
   "shapes":[  
      {  
         "shape":"square",
         "color":"blue"
      },
      {  
         "shape":"circle",
         "color":"red"
      }
   ]
},
{  
   "_id":ObjectId("562e7c594c12942f08fe4193"),
   "shapes":[  
      {  
         "shape":"square",
         "color":"black"
      },
      {  
         "shape":"circle",
         "color":"green"
      }
   ]
}

做查询：

db.test.find({"shapes.color": "red"}, {"shapes.color": 1})

或者

db.test.find({shapes: {"$elemMatch": {color: "red"}}}, {"shapes.color": 1})

返回匹配的文档（文档 1），但始终包含所有数组项shapes：

{ "shapes": 
  [
    {"shape": "square", "color": "blue"},
    {"shape": "circle", "color": "red"}
  ] 
}

但是，我想仅使用包含以下内容的数组获取文档（文档 1）color=red：

{ "shapes": 
  [
    {"shape": "circle", "color": "red"}
  ] 
}

我怎样才能做到这一点？

4

15 回答 15

484

MongoDB 2.2 的新$elemMatch投影运算符提供了另一种更改返回文档以仅包含第一个匹配shapes元素的方法：

db.test.find(
    {"shapes.color": "red"}, 
    {_id: 0, shapes: {$elemMatch: {color: "red"}}});

回报：

{"shapes" : [{"shape": "circle", "color": "red"}]}

在 2.2 中，您还可以使用 来执行此操作$ projection operator，其中$投影对象字段名称中的 表示查询中该字段的第一个匹配数组元素的索引。以下返回与上述相同的结果：

db.test.find({"shapes.color": "red"}, {_id: 0, 'shapes.$': 1});

MongoDB 3.2 更新

从 3.2 版本开始，您可以使用新的$filter聚合运算符在投影期间过滤数组，这具有包括所有匹配项的好处，而不仅仅是第一个匹配项。

db.test.aggregate([
    // Get just the docs that contain a shapes element where color is 'red'
    {$match: {'shapes.color': 'red'}},
    {$project: {
        shapes: {$filter: {
            input: '$shapes',
            as: 'shape',
            cond: {$eq: ['$$shape.color', 'red']}
        }},
        _id: 0
    }}
])

结果：

[ 
    {
        "shapes" : [ 
            {
                "shape" : "circle",
                "color" : "red"
            }
        ]
    }
]
于 2012-09-03T04:19:22.347 回答
110

MongoDB 2.2+ 中的新聚合框架提供了 Map/Reduce 的替代方案。该$unwind运算符可用于将您的shapes数组分隔为可以匹配的文档流：

db.test.aggregate(
  // Start with a $match pipeline which can take advantage of an index and limit documents processed
  { $match : {
     "shapes.color": "red"
  }},
  { $unwind : "$shapes" },
  { $match : {
     "shapes.color": "red"
  }}
)

结果是：

{
    "result" : [
        {
            "_id" : ObjectId("504425059b7c9fa7ec92beec"),
            "shapes" : {
                "shape" : "circle",
                "color" : "red"
            }
        }
    ],
    "ok" : 1
}
于 2012-09-03T03:44:07.393 回答
33

警告：在MongoDB 2.2 及更高版本的新功能推出之前，此答案提供了当时相关的解决方案。如果您使用的是更新版本的 MongoDB，请参阅其他答案。

字段选择器参数仅限于完整的属性。它不能用于选择数组的一部分，只能选择整个数组。我尝试使用$ 位置运算符，但没有奏效。

最简单的方法是只过滤客户端中的形状。

如果你真的需要直接从 MongoDB 得到正确的输出，你可以使用 map-reduce来过滤形状。

function map() {
  filteredShapes = [];

  this.shapes.forEach(function (s) {
    if (s.color === "red") {
      filteredShapes.push(s);
    }
  });

  emit(this._id, { shapes: filteredShapes });
}

function reduce(key, values) {
  return values[0];
}

res = db.test.mapReduce(map, reduce, { query: { "shapes.color": "red" } })

db[res.result].find()
于 2010-10-21T09:25:09.430 回答
31

另一种有趣的方法是使用$redact，这是MongoDB 2.6的新聚合功能之一。如果您使用的是 2.6，则不需要 $unwind，如果您有大型数组，这可能会导致性能问题。

db.test.aggregate([
    { $match: { 
         shapes: { $elemMatch: {color: "red"} } 
    }},
    { $redact : {
         $cond: {
             if: { $or : [{ $eq: ["$color","red"] }, { $not : "$color" }]},
             then: "$$DESCEND",
             else: "$$PRUNE"
         }
    }}]);

$redact “根据文件本身存储的信息限制文件的内容”。所以它只会在文档内部运行。它基本上从上到下扫描您的文档，并检查它是否与您的if条件匹配$cond，如果匹配，它将保留 content( $$DESCEND) 或 remove( $$PRUNE)。

在上面的示例中，首先$match返回整个shapes数组，然后 $redact 将其剥离到预期的结果。

请注意，这{$not:"$color"}是必要的，因为它也会扫描顶层文档，如果在顶层$redact找不到color字段，这将返回false可能会删除我们不想要的整个文档。

于 2014-06-04T08:31:35.973 回答
28

您可以更好地查询匹配的数组元素$slice，这有助于返回数组中的重要对象。

db.test.find({"shapes.color" : "blue"}, {"shapes.$" : 1})

$slice当您知道元素的索引时会很有帮助，但有时您希望哪个数组元素符合您的条件。您可以使用运算符返回匹配元素$。

于 2014-09-18T08:35:27.610 回答
21 
 db.getCollection('aj').find({"shapes.color":"red"},{"shapes.$":1})

输出

{

   "shapes" : [ 
       {
           "shape" : "circle",
           "color" : "red"
       }
   ]
}
于 2016-12-07T06:25:02.117 回答
14

在 mongodb 中查找的语法是

    db.<collection name>.find(query, projection);

以及您编写的第二个查询，即

    db.test.find(
    {shapes: {"$elemMatch": {color: "red"}}}, 
    {"shapes.color":1})

在这里，您$elemMatch在查询部分使用了运算符，而如果您在投影部分使用此运算符，那么您将获得所需的结果。您可以将查询写为

     db.users.find(
     {"shapes.color":"red"},
     {_id:0, shapes: {$elemMatch : {color: "red"}}})

这将为您提供所需的结果。

于 2013-12-22T08:14:14.123 回答
9

感谢约翰尼香港。

这里我只是想添加一些更复杂的用法。

// Document 
{ 
"_id" : 1
"shapes" : [
  {"shape" : "square",  "color" : "red"},
  {"shape" : "circle",  "color" : "green"}
  ] 
} 

{ 
"_id" : 2
"shapes" : [
  {"shape" : "square",  "color" : "red"},
  {"shape" : "circle",  "color" : "green"}
  ] 
} 


// The Query   
db.contents.find({
    "_id" : ObjectId(1),
    "shapes.color":"red"
},{
    "_id": 0,
    "shapes" :{
       "$elemMatch":{
           "color" : "red"
       } 
    }
}) 


//And the Result

{"shapes":[
    {
       "shape" : "square",
       "color" : "red"
    }
]}
于 2014-03-23T07:05:06.817 回答
8

你只需要运行查询

db.test.find(
{"shapes.color": "red"}, 
{shapes: {$elemMatch: {color: "red"}}});

这个查询的输出是

{
    "_id" : ObjectId("562e7c594c12942f08fe4192"),
    "shapes" : [ 
        {"shape" : "circle", "color" : "red"}
    ]
}

如您所料，它将给出与颜色匹配的数组中的确切字段：'red'。

于 2016-09-17T17:22:49.267 回答
4

与此同时， $project其他明智匹配的元素将与文档中的其他元素结合在一起会更合适。

db.test.aggregate(
  { "$unwind" : "$shapes" },
  { "$match" : { "shapes.color": "red" } },
  { 
    "$project": {
      "_id":1,
      "item":1
    }
  }
)
于 2013-02-09T15:45:13.257 回答
2

同样，您可以找到多个

db.getCollection('localData').aggregate([
    // Get just the docs that contain a shapes element where color is 'red'
  {$match: {'shapes.color': {$in : ['red','yellow'] } }},
  {$project: {
     shapes: {$filter: {
        input: '$shapes',
        as: 'shape',
        cond: {$in: ['$$shape.color', ['red', 'yellow']]}
     }}
  }}
])
于 2020-02-28T07:15:43.647 回答
1 
db.test.find( {"shapes.color": "red"}, {_id: 0})
于 2018-10-25T08:00:51.493 回答
1

使用聚合函数并$project获取文档中的特定对象字段

db.getCollection('geolocations').aggregate([ { $project : { geolocation : 1} } ])

结果：

{
    "_id" : ObjectId("5e3ee15968879c0d5942464b"),
    "geolocation" : [ 
        {
            "_id" : ObjectId("5e3ee3ee68879c0d5942465e"),
            "latitude" : 12.9718313,
            "longitude" : 77.593551,
            "country" : "India",
            "city" : "Chennai",
            "zipcode" : "560001",
            "streetName" : "Sidney Road",
            "countryCode" : "in",
            "ip" : "116.75.115.248",
            "date" : ISODate("2020-02-08T16:38:06.584Z")
        }
    ]
}
于 2020-02-09T07:43:21.610 回答
1

尽管这个问题是在 9.6 年前提出的，但这对很多人都有巨大的帮助，我就是其中之一。谢谢大家的所有疑问，提示和答案。从这里的一个答案中挑选。我发现以下方法也可以用于投影父文档中的其他字段。这可能对某人有所帮助。

对于以下文档，需要确定员工 (emp #7839) 是否设置了 2020 年的休假历史记录。休假历史记录是作为父 Employee 文档中的嵌入文档实现的。

db.employees.find( {"leave_history.calendar_year": 2020}, 
    {leave_history: {$elemMatch: {calendar_year: 2020}},empno:true,ename:true}).pretty()


{
        "_id" : ObjectId("5e907ad23997181dde06e8fc"),
        "empno" : 7839,
        "ename" : "KING",
        "mgrno" : 0,
        "hiredate" : "1990-05-09",
        "sal" : 100000,
        "deptno" : {
                "_id" : ObjectId("5e9065f53997181dde06e8f8")
        },
        "username" : "none",
        "password" : "none",
        "is_admin" : "N",
        "is_approver" : "Y",
        "is_manager" : "Y",
        "user_role" : "AP",
        "admin_approval_received" : "Y",
        "active" : "Y",
        "created_date" : "2020-04-10",
        "updated_date" : "2020-04-10",
        "application_usage_log" : [
                {
                        "logged_in_as" : "AP",
                        "log_in_date" : "2020-04-10"
                },
                {
                        "logged_in_as" : "EM",
                        "log_in_date" : ISODate("2020-04-16T07:28:11.959Z")
                }
        ],
        "leave_history" : [
                {
                        "calendar_year" : 2020,
                        "pl_used" : 0,
                        "cl_used" : 0,
                        "sl_used" : 0
                },
                {
                        "calendar_year" : 2021,
                        "pl_used" : 0,
                        "cl_used" : 0,
                        "sl_used" : 0
                }
        ]
}
于 2020-04-16T10:07:45.160 回答
0

如果要同时进行过滤，设置和查找。

let post = await Post.findOneAndUpdate(
          {
            _id: req.params.id,
            tasks: {
              $elemMatch: {
                id: req.params.jobId,
                date,
              },
            },
          },
          {
            $set: {
              'jobs.$[i].performer': performer,
              'jobs.$[i].status': status,
              'jobs.$[i].type': type,
            },
          },
          {
            arrayFilters: [
              {
                'i.id': req.params.jobId,
              },
            ],
            new: true,
          }
        );
于 2022-02-18T01:37:52.430 回答