我需要帮助从文档中获取具有字段(级别)最大值的数组元素。然后统计数组元素字段“bssid”分组的总出现次数。

考虑以下数据

/* 1 */
{
    "_id" : "18:59:36:0c:94:a3",
    "timestamp" : "1460012567",
    "apdata" : [{
        "bssid" : "f4:b7:e2:56:e4:20",
        "ssid" : "Test Network2",
        "level" : -55
    }, {
        "bssid" : "b8:a3:86:67:03:56",
        "ssid" : "Test Network1",
        "level" : -76
    }]
}
/* 2 */
{
    "_id" : "d0:b3:3f:b9:42:38",
    "timestamp" : "1460013345",
    "apdata" : [{
        "bssid" : "f4:b7:e2:56:e4:20",
        "ssid" : "Test Network2",
        "level" : -65
    }, {
        "bssid" : "b8:a3:86:67:03:56",
        "ssid" : "Test Network1",
        "level" : -46
    }]
}
/* 3 */
{
    "_id" : "d0:b3:3f:b9:42:41",
    "timestamp" : "1460013145",
    "apdata" : [{
        "bssid" : "f4:b7:e2:56:e4:20",
        "ssid" : "Test Network2",
        "level" : -65
    }, {
        "bssid" : "b8:a3:86:67:03:56",
        "ssid" : "Test Network1",
        "level" : -46
    }]
 }

需要的输出是

{
    "bssid" : "f4:b7:e2:56:e4:20",
    "ssid" : "Test Network2",
    "count" : 1
}, {
    "bssid" : "b8:a3:86:67:03:56",
    "ssid" : "Test Network1",
    "count" : 2
}

这是整个集合中每个文档的数组中每个 bssid 具有最大值的次数。

最佳答案

如果您有可用的 MongoDB 3.2，那么您可以这样做:

db.sample.aggregate([
  { "$project": {
    "apdata": {
      "$arrayElemAt": [
        { "$filter": {
          "input": "$apdata",
          "as": "el",
          "cond": {
            "$eq": [ 
              "$$el.level",
              { "$max": {
                "$map": {
                  "input": "$apdata",
                  "as": "data",
                  "in": "$$data.level"
                }
              }}
            ]
          }
        }},
        0
      ]
    }
  }},
  { "$group": {
    "_id": "$apdata.bssid",
    "ssid": { "$first": "$apdata.ssid" },
    "count": { "$sum": 1 }
  }}
])

至少对于 MongoDB 2.6 你需要这样做:

db.sample.aggregate([
  { "$unwind": "$apdata" },
  { "$group": {
    "_id": "$_id",
    "apdata": { "$push": "$apdata" },
    "max": { "$max": "$apdata.level" }
  }},
  { "$unwind": "$apdata" },
  { "$redact": {
    "$cond": {
      "if": { "$eq": [ "$apdata.level", "$max" ] },
      "then": "$$KEEP",
      "else": "$$PRUNE"
    }
  }},
  { "$group": {
    "_id": "$apdata.bssid",
    "ssid": { "$first": "$apdata.ssid" },
    "count": { "$sum": 1 }
  }}
])

对于 MongoDB 2.4 或 2.2 是这样的:

db.sample.aggregate([
  { "$unwind": "$apdata" },
  { "$group": {
    "_id": "$_id",
    "apdata": { "$push": "$apdata" },
    "max": { "$max": "$apdata.level" }
  }},
  { "$unwind": "$apdata" },
  { "$project": {
    "apdata": 1,
    "isMax": { "$eq": [ "$apdata.level", "$max" ] }
  }},
  { "$match": { "isMax": true } },
  { "$group": {
    "_id": "$apdata.bssid",
    "ssid": { "$first": "$apdata.ssid" },
    "count": { "$sum": 1 }
  }}
])

在所有情况下 $max用于“首先”获取每个文档中数组的“最大”值，然后您可以使用它来“过滤”数组内容，然后再在 $group 中使用它。 .此方法仅因版本而异

MongoDB 3.2:允许 $max直接处理值的“数组”。所以 $map用于获取 “level” 值并找出“max”实际是多少。

然后 $filter可用于仅返回与“最大”值匹配的数组元素，最后是 $arrayElemAt用于将“唯一”(两个可能的和“零”索引中的)元素作为普通文档返回。

整个过程可以在$group中完成“仅”如果您基本上为 _id 重复整个语句并获得 $first "ssid" 值，但写成 $project 会更容易一些分别进行演示。

MongoDB 2.6:它缺少更高级的运算符，最值得注意的是 $max 的能力“直接”在数组上工作。值得注意的是需要 $unwind首先是数组然后实际上是$group仅在原始文档上，仅仅是为了获得“最大”值。

那么进程真的需要你$unwind再次因为您稍后将对数组中的元素进行分组，然后使用 $redact过滤内容。这是 $match 的“逻辑”形式您可以在其中直接将 "level" 与早期计算的“max”进行比较。所以不是“最大”的元素被删除。

MongoDB 2.4:再次基本相同的逻辑，除了代替$redact你实际上需要物理 $project为了在文档中放置一个字段以用于过滤 $match .

所有版本都有相同的最终$group ，您可以在其中为分组键和 $first 提供 "apdata.bssid" 的路径在 "ssid" 和简单的 $sum 的分组边界上产生结果计算结果中分组键的出现次数。

一切返回如下:

{ "_id" : "f4:b7:e2:56:e4:20", "ssid" : "Test Network2", "count" : 1 }
{ "_id" : "b8:a3:86:67:03:56", "ssid" : "Test Network1", "count" : 2 }

实际上，MongoDB 3.2 最“有效”的形式如下:

db.sample.aggregate([
  { "$group": {
    "_id": {
      "$arrayElemAt": [
        { "$map": {
          "input": {
            "$filter": {
              "input": "$apdata",
              "as": "el",
              "cond": {
                "$eq": [ 
                  "$$el.level",
                  { "$max": {
                    "$map": {
                      "input": "$apdata",
                      "as": "data",
                      "in": "$$data.level"
                    }
                  }}
                ]
              }
            }            
          },
          "as": "apdata",
          "in": {
            "bssid": "$$apdata.bssid",
            "ssid": "$$apdata.ssid"
          }
        }},
        0
      ]
    },
    "count": { "$sum": 1 }
  }}
])

由于复合 _id 的形式略有不同，但它是一个单一的 $group仅阶段，不重复整个过程以查找“最大”值的数组元素数据:

  {
    "_id" : {
      "bssid" : "b8:a3:86:67:03:56",
      "ssid" : "Test Network1"
    },
    "count" : 2
  }
  {
    "_id" : {
      "bssid" : "f4:b7:e2:56:e4:20",
      "ssid" : "Test Network2"
    },
    "count" : 1
  }

关于mongodb - 如何在聚合中匹配和分组具有最大值的数组元素，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36471621/