如何返回猫鼬中同一字段的多个计数

如前所述，您可以使用聚合框架在一个实际查询中实现这一点，甚至有几种方法可以实现这一结果，具体取决于您想要什么。但实际上，.count()作为一种通用方法存在一个小的性能问题，最好通过一个例子来说明。

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

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();
    }
}

因此，在这种情况下，仅仅是一个100000个文档集合，几乎没有数据，也没有索引，这并不会产生真正的影响。分布应该是相当均匀和随机的，足以表明这一点。

然后一些基本的代码来采样不同的方法：

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，但您可以看到其时间为204ms。

"第二个"结果是具有聚合的单个文档结果。这使用$cond运算符，以便在一个文档中将每个结果"拆分"为其自己的属性。这里花费的时间明显少于140毫秒。

最后，对于"第三个"结果，将同时执行的两个查询的响应组合在一起，使用"async.parallel"来管理结果的并行运行和排序。所花费的时间为86ms，不到原始聚合语句的一半，但仍明显少于其他更快的聚合选项。

为什么会这样？好吧，MongoDB本身在执行常规查询时从查询引擎返回的"游标"中保存了一些特定信息。部分信息是返回结果的"计数"。由于查询引擎已经完成了扫描和累积这个"匹配"总数的工作，所以这个数字是存在的，不需要更多的工作来获得"计数"。

相比之下，尽管聚合框架在很多方面都很有用，但在$group期间，聚合框架以一种非常不同的方式来实现这一点。这在一定程度上体现在两种聚合方法之间的性能差异上，但最重要的是，基本的"查询引擎"以更有效的方式"计数匹配"事物。

根据实际数据，尤其是对于这种true/false匹配，对该属性进行索引甚至应该产生"更快"的结果。

但这里的要点是，对于简单地"计算"属性的匹配值，如果这样做是可行的（true/false是一个很好的例子），那么最具性能的选项是运行"并行查询"，如本例所示。性能改进通常是您正在"计数"的不同属性值数量的一个因素。

所以聚合是很好的，但在这种情况下，它不是赢家。mongoose使用的节点本机驱动程序（与许多好的驱动程序实现一样）默认使用"连接池"。虽然这对于事件驱动的应用程序来说通常是一个好主意，因为有可用于其他并发操作的连接，但实际运行多个并发操作以获得结果也是一个有效的用途。

通用查询引擎中的优化，加上有效地"同时"发出两个.count()语句，然后确保等待组合结果，可以为此类操作提供最佳性能结果。一般来说，除了基本计数之外的任何事情都不是真的，但这完全取决于你实际想做什么

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

您可以使用聚合，按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);
  });
}