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

如前所述，您可以在使用聚合框架的一个实际查询中执行此操作，并且根据您的需要，甚至有几种方法可以实现该结果。但实际上，.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();
    }
}

因此，只需要一个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
    ]
  }
]

因此，在没有任何进一步操作的情况下，结果显示（并且公平地说，这是经过几次迭代才能确保数据被“加热”并加载到内存中），每种形式都存在显着差异

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

“第二个”结果是带有聚合的单个文档结果。这使用$cond运算符将每个结果“拆分”到一个文档中的自己的属性中。这里花费的时间明显少于140毫秒。

最后，对于“第三”结果，响应由两个使用"async.parallel"同时执行的查询组合，以管理结果的并行运行和排序。所花费的时间是86ms，小于原始聚合语句的一半，但仍然明显小于更快的其他聚合选项。

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

相比之下，虽然聚合框架和$group在很多方面都很有用，但它在很多方面都有用。这在两种聚合方法中的每一种之间的性能差异中都是显而易见的，但主要的是基本的“查询引擎”以更有效的方式“计算匹配”事物。

根据实际数据，特别是对于这种true/false匹配，然后对该属性进行索引甚至应该产生“更快”的结果。

但这里的要点是，简单地“计算”一个属性的匹配值，这样做是可行的（true/false是一个很好的例子）然后最高性能的选项是运行“并行查询”已在此示例中显示。性能改进通常是您“计算”的不同属性值的数量的一个因素。

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

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

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

Answer 2

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

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

2 个答案: