如何在猫鼬中为同一字段返回多个计数？

Question

基本上，我想将对mongo的两个单独的调用合并为一个单独的调用，但是我不确定如何做到。 如果有人可以给我一些指导，我将不胜感激！ 谢谢！

RatingSchema.statics.getPostRating = function(post, callback)
{
    this.count({ post: post, positiveReview: true }, function(err, posCount){
    if(err)
    {
            callback(err);
            return;
    }
    this.count({ post: , positiveReview: false }, function(err, negCount){
        if(err)
        {
            callback(err);
            return
        }
        callback(err, posCount, negCount)
    }

}

Answer 1

您可以使用aggregation ，按positiveReview分组：

RatingSchema.statics.getPostRating = function(post, callback)
{
  this.aggregate([
    {
      "$group": {
        "_id": "$positiveReview",
        "count": {"$sum": 1}
      }
    }
  ], function(err, results){

     // in **results**, you have count by `positiveReview`
     callback(err, results);
  });
}

Answer 2

如前所述，您可以使用聚合框架在一个实际的查询中执行此操作，根据您的需要，甚至可以通过几种方法来实现该结果。 但是实际上， .count()作为一个通用方法存在一些性能问题，最好通过一个示例来说明。

首先，为了方便起见，我将在外壳中设置一些数据：

var bulk = db.testcol.initializeOrderedBulkOp();

for ( var x=1; x <= 100000; x++ ) {
    bulk.insert({ value: Math.floor(Math.random(2)*2) });
    if ( x % 1000 == 0 ) {
        bulk.execute();
        bulk = db.testcol.initializeOrderedBulkOp();
    }
}

因此，仅是一个100,000个文档集合，几乎没有数据，也没有索引，因为在这种情况下，这实际上并不会有所作为。 分布应该相当均匀且随机，足以说明问题。

然后，一些基本代码对不同的方法进行了示例：

var async = require('async'),
    mongoose = require('mongoose'),
    Schema = mongoose.Schema;


var testSchema = new Schema({
  value: Number
});

mongoose.connect('mongodb://localhost/test');

var Test = mongoose.model( 'Test', testSchema, 'testcol' );


async.series(
  [
    // Time aggregation two results
    function(callback) {
      var start = new Date();
      Test.aggregate(
        [{ "$group": { "_id": "$value", "count": { "$sum": 1 } } }],
        function(err,result) {
          var obj = {
            "start": start,
            "end": new Date()
          };
          obj.time = obj.end.valueOf() - obj.start.valueOf();
          obj.result = result;
          callback(err,obj);
        }
      );
    },

    // Time aggregation conditional
    function(callback) {
      var start = new Date();
      Test.aggregate(
        [
          { "$group": {
            "_id": null,
            "positive": {
              "$sum": {
                "$cond": [
                  { "$eq": [ "$value", 1 ] },
                  1,
                  0
                ]
              }
            },
            "negative": {
              "$sum": {
                "$cond": [
                  { "$eq": [ "$value", 0 ] },
                  1,
                  0
                ]
              }
            }
          }}
        ],
        function(err,result) {
          var obj = {
            "start": start,
            "end": new Date()
          };
          obj.time = obj.end.valueOf() - obj.start.valueOf();
          obj.result = result;
          callback(err,obj);
        }
      );
    },

    // Time query parallel
    function(callback) {
      var start = new Date();
      async.parallel(
        [
          function(callback) {
            Test.count({ value: 1 },callback);
          },
          function(callback) {
            Test.count({ value: 0 },callback);
          }
        ],
        function(err,results) {
          var obj = {
            "start": start,
            "end": new Date()
          };
          obj.time = obj.end.valueOf() - obj.start.valueOf();
          obj.result = results;
          callback(err,obj);
        }
      );
    }
  ],
  function(err,results) {
    if (err) throw err;
    console.log( JSON.stringify( results, undefined, 2 ) );
  }
);

当然，结果是最重要的一点：

[
  {
    "start": "2014-10-01T08:18:28.059Z",
    "end": "2014-10-01T08:18:28.263Z",
    "time": 204,
    "result": [
      {
        "_id": 1,
        "count": 49965
      },
      {
        "_id": 0,
        "count": 50035
      }
    ]
  },
  {
    "start": "2014-10-01T08:18:28.264Z",
    "end": "2014-10-01T08:18:28.404Z",
    "time": 140,
    "result": [
      {
        "_id": null,
        "positive": 49965,
        "negative": 50035
      }
    ]
  },
  {
    "start": "2014-10-01T08:18:28.405Z",
    "end": "2014-10-01T08:18:28.491Z",
    "time": 86,
    "result": [
      49965,
      50035
    ]
  }
]

因此，在没有任何进一步操作的情况下，结果表明（公平地说，这是在经过几次迭代以确保将数据“预热”并加载到内存后使用），每种形式都存在显着差异。

“第一个”结果是一个基本的聚合语句，该语句返回两行，其中包含存在的每个“值”的计数。 根据插入条件，它们只能是1或0 ，但是您可以看到此时间为204毫秒。

“第二”结果是具有汇总的单个文档结果。 这使用$cond运算符，以便将每个结果“拆分”到一个文档中自己的属性中。 此处花费的时间明显少于140ms。

最后，对于“第三”结果，使用“ async.parallel”将同时执行的两个查询合并为响应，以管理结果的并行运行和排序。 所花费的时间为86毫秒，不到原始聚合语句的一半，但仍然比另一个更快的聚合选项要短得多。

为什么是这样？ 好吧，MongoDB本身在执行常规查询时会在查询引擎返回的“游标”中保存一些特定信息。 该信息的一部分是返回结果的“计数”。 由于查询引擎已经完成了它的工作，因此扫描并累加了这个“匹配”总数，因此存在此数字，并且无需进行其他工作即可获得“计数”。

相比之下，尽管聚合框架对许多事情有用，但它和$group实现方式却大不相同。 这在两种聚合方法之间的性能差异中部分可见，但是主要的事情是基本的“查询引擎”以更有效的方式“计数”事物。

根据实际数据，尤其是对于这种true/false匹配，在该属性上建立索引甚至还会产生“更快”的结果。

但这里的要点是，仅对属性的匹配值进行“计数”（在可行的情况下可行）（并且true/false是一个好例子），那么性能最高的选项是运行“并行查询”已在此示例中显示。 性能提高通常是您要“计数”的不同属性值数量的一个因素。

因此，汇总非常棒，但在这种情况下，它不是赢家。 猫鼬使用的节点本机驱动程序（与许多良好的驱动程序实现一样）默认情况下使用“连接池”。 尽管对于事件驱动的应用程序来说这通常是一个好主意，因为存在可用于其他并发操作的连接，但它实际上是运行多个并发操作以获得结果的有效方法。

常规查询引擎中的优化与有效地“同时”发出两个.count()语句相结合，然后确保您等待组合的结果，从而为此类操作提供了最佳性能结果。 一般而言，对于基本计数以外的任何内容都不是正确的，但这完全取决于您实际尝试执行的操作。

测试驱动开发的一部分通常应该是“测试备用案例”。 这将根据获得的结果引导您朝正确的方向前进。