javascript - 计算键值的出现次数

Question

我有很多具有很多属性的文档。在特定的 $match 传递之后，我以一个小节结束。这里简化了:

[
    {"name": "foo", "code": "bbb"},
    {"name": "foo", "code": "aaa"},
    {"name": "foo", "code": "aaa"},
    {"name": "foo", "code": "aaa"},
    {"name": "bar", "code": "aaa"},
    {"name": "bar", "code": "aaa"},
    {"name": "bar", "code": "aaa"},
    {"name": "baz", "code": "aaa"},
    {"name": "baz", "code": "aaa"}
]

我想计算某些属性的出现次数，所以我最终得到这个(简化):

{
    "name": {
        "foo": 4, 
        "bar": 3,
        "baz": 2
    },
    "code": {
        "bbb": 1,
        "aaa": 8
    }
}

(或者我之后可以用 Node.js ‘翻译’的接近的东西)

我已经做了一个 $group 阶段来计算其他属性(不同)。理想情况下，我会 $addToSet 并计算类似值被添加到集合中的次数。但我想不通。

或者我正在考虑 $push 来结束这个(简化):

{
    "name": ["foo", "foo", "foo", "foo", "bar", "bar", "bar", "baz", "baz"],
    "code": ["bbb", "aaa", "aaa", "aaa", "aaa", "aaa", "aaa", "aaa", "aaa", ]
}

但我也不知道如何将其变成(接近于)上述假设结果。

仅对于单个字段，最接近的方法是使用上面的 $push 然后我可以使用 $group:

"$group": {
    "_id": {"_id": "$_id", "name": "$name"},
    "nameCount": {"$sum": 1}
}

现在我有 _id.name 和 nameCount。但是我已经失去了所有以前计算的属性，大约 20 个。

有没有办法做(接近)我想做的事？

Note: Using MongoDB 3.2

Answer 1

对于 MongoDB 3.2，如果您想在返回的文档中将“数据”值作为“键”返回，您几乎只能使用 mapReduce。然而，在某些情况下，您实际上“不需要”MongoDB 为您做那部分工作。但要考虑这些方法:

map 缩减

db.stuff.mapReduce(
  function() { 
    emit(null, {
     name: { [this.name]: 1 },
     code: { [this.code]: 1 }
    })
   },
  function(key,values) {
     let obj = { name: {}, code: {} };
     values.forEach(value => {
       ['name','code'].forEach(key => {
         Object.keys(value[key]).forEach(k => {
           if (!obj[key].hasOwnProperty(k))
             obj[key][k] = 0;
           obj[key][k] += value[key][k];
         })    
       })
     });
     return obj;    
  },
  { "out": { "inline": 1 } }
)

返回:

    {
        "_id" : null,
        "value" : {
            "name" : {
                "foo" : 4.0,
                "bar" : 3.0,
                "baz" : 2.0
            },
            "code" : {
                "bbb" : 1.0,
                "aaa" : 8.0
            }
        }
    }

---

聚合

对于 MongoDB 3.4 及更高版本，您可以使用 $arrayToObject 将其 reshape 为“键/值”对象。并且比简单地使用 $push 来制作两个大数组更有效，这在现实世界中几乎肯定会打破 BSON 限制。

这个“或多或少”反射(reflect)了 mapReduce() 操作:

db.stuff.aggregate([
  { "$project": {
    "_id": 0,
    "data": [
      { "k": "name", "v": { "k": "$name", "count": 1 } },
      { "k": "code", "v": { "k": "$code", "count": 1 } }
    ]
  }},
  { "$unwind": "$data" },
  { "$group": {
    "_id": { "k": "$data.k",  "v": "$data.v.k" },
    "count": { "$sum": "$data.v.count" }
  }},
  { "$group": {
    "_id": "$_id.k",
    "v": { "$push": { "k": "$_id.v", "v": "$count" } }
  }},
  { "$group": {
    "_id": null,
    "data": { "$push": { "k": "$_id", "v": "$v" } }  
  }},
  { "$replaceRoot": {
    "newRoot": {
      "$arrayToObject": {
        "$map": {
          "input": "$data",
          "in": { 
            "k": "$$this.k",
            "v": { "$arrayToObject": "$$this.v" }
          }
        }    
      }
    }  
  }}
])

它具有相似的输出(不通过应用 $sort 强制对键进行排序):

{
    "code" : {
        "bbb" : 1.0,
        "aaa" : 8.0
    },
    "name" : {
        "baz" : 2.0,
        "foo" : 4.0,
        "bar" : 3.0
    }
}

所以它只是在我们实际使用新功能的最后阶段，到那时为止的输出非常相似，并且很容易在代码中 reshape :

{
    "_id" : null,
    "data" : [ 
        {
            "k" : "code",
            "v" : [ 
                {
                    "k" : "bbb",
                    "v" : 1.0
                }, 
                {
                    "k" : "aaa",
                    "v" : 8.0
                }
            ]
        }, 
        {
            "k" : "name",
            "v" : [ 
                {
                    "k" : "baz",
                    "v" : 2.0
                }, 
                {
                    "k" : "foo",
                    "v" : 4.0
                }, 
                {
                    "k" : "bar",
                    "v" : 3.0
                }
            ]
        }
    ]
}

所以事实上我们可以做到这一点:

db.stuff.aggregate([
  { "$project": {
    "_id": 0,
    "data": [
      { "k": "name", "v": { "k": "$name", "count": 1 } },
      { "k": "code", "v": { "k": "$code", "count": 1 } }
    ]
  }},
  { "$unwind": "$data" },
  { "$group": {
    "_id": { "k": "$data.k",  "v": "$data.v.k" },
    "count": { "$sum": "$data.v.count" }
  }},
  { "$group": {
    "_id": "$_id.k",
    "v": { "$push": { "k": "$_id.v", "v": "$count" } }
  }},
  { "$group": {
    "_id": null,
    "data": { "$push": { "k": "$_id", "v": "$v" } }  
  }},
  /*
  { "$replaceRoot": {
    "newRoot": {
      "$arrayToObject": {
        "$map": {
          "input": "$data",
          "in": { 
            "k": "$$this.k",
            "v": { "$arrayToObject": "$$this.v" }
          }
        }    
      }
    }  
  }}
  */
]).map( doc =>
  doc.data.map( d => ({
     k: d.k,
     v: d.v.reduce((acc,curr) => 
      Object.assign(acc,{ [curr.k]: curr.v })
      ,{}
     )
  })).reduce((acc,curr) => 
    Object.assign(acc,{ [curr.k]: curr.v })
    ,{}
  )
)

这只是因为聚合框架没有在早期版本的输出中使用“命名键”的功能，所以您通常不需要它们。由于我们实际使用新功能的唯一地方是在“最终”阶段，但我们可以通过简单地在客户端代码中 reshape 最终输出来轻松地做到这一点。

当然，结果是一样的:

[
    {
        "code" : {
            "bbb" : 1.0,
            "aaa" : 8.0
        },
        "name" : {
            "baz" : 2.0,
            "foo" : 4.0,
            "bar" : 3.0
        }
    }
]

因此，了解您实际需要应用此类转换的确切“位置”的教训会有所帮助。这里是“结束”，因为我们在任何“聚合”阶段都不需要它，因此您只需 reshape 可以从聚合框架本身最佳提供的结果。

---

坏方法

如前所述，到目前为止，您的尝试对于小数据可能没问题，但在大多数现实世界的情况下，将集合中的所有项目“推送”到一个文档中而不减少将打破 16MB 的 BSON 限制。

它实际上会停留在下面的地方，然后你可以使用类似这个怪物的东西 $reduce :

db.stuff.aggregate([
  { "$group": {
    "_id": null,
    "name": { "$push": "$name" },
    "code": { "$push": "$code" }
  }},
  { "$replaceRoot": {
    "newRoot": { 
      "$arrayToObject": {
        "$map": {
          "input": [
            { "k": "name", "v": "$name" },
            { "k": "code", "v": "$code" }
          ],
          "as": "m",
          "in": {
            "k": "$$m.k",
            "v": {
              "$arrayToObject": {
                "$reduce": {
                  "input": "$$m.v",
                  "initialValue": [],
                  "in": {
                    "$cond": {
                      "if": { 
                        "$in": [
                          "$$this",
                          { "$map": {
                            "input": "$$value",
                            "as": "v",
                            "in": "$$v.k"
                          }}
                        ]
                      },
                      "then": {
                        "$concatArrays": [
                          { "$filter": {
                            "input": "$$value",
                            "as": "v",
                            "cond": { "$ne": [ "$$v.k", "$$this" ] }
                          }},
                          [{
                            "k": "$$this",
                            "v": {
                              "$sum": [
                                { "$arrayElemAt": [
                                  "$$value.v",
                                  { "$indexOfArray": [ "$$value.k", "$$this" ] }
                                ]},
                                1
                              ]
                            }    
                          }]
                        ]    
                      },
                      "else": {
                        "$concatArrays": [
                          "$$value",
                          [{ "k": "$$this", "v": 1 }]
                        ]    
                      }
                    } 
                  }
                }
              }
            }
          }
        }
      }
    }
  }}
])

产生:

{
    "name" : {
        "foo" : 4.0,
        "bar" : 3.0,
        "baz" : 2.0
    },
    "code" : {
        "bbb" : 1.0,
        "aaa" : 8.0
    }
}

或者实际上是客户端代码中的相同缩减过程:

db.stuff.aggregate([
  { "$group": {
    "_id": null,
    "name": { "$push": "$name" },
    "code": { "$push": "$code" }
  }},
]).map( doc => 
  ["name","code"].reduce((acc,curr) =>
    Object.assign(
      acc,
      { [curr]: doc[curr].reduce((acc,curr) =>
          Object.assign(acc,
            (acc.hasOwnProperty(curr))
              ? { [curr]: acc[curr] += 1 }
              : { [curr]: 1 }
          ),{}
        )
      }
    ),
    {}
  )
)

同样的结果:

{
    "name" : {
        "foo" : 4.0,
        "bar" : 3.0,
        "baz" : 2.0
    },
    "code" : {
        "bbb" : 1.0,
        "aaa" : 8.0
    }
}