如何返回猫鼬同一领域的多个计数？

Question

基本上我想把两个单独的调用结合成一个单一的调用，但我不完全确定如何去做。如果有人可以给我一些指导，我将不胜感激！谢谢！

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()作为一个通用方法的性能问题，最好用一个例子来说明。

首先，我将刚刚成立的壳一些数据，方便：

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

所以，简单地只是10万文档集，几乎没有数据，因为没有指数将没有真正的区别这个案例。分布应该是相当均匀和随机的，以表明这一点。

然后一些基本的代码来品尝不同的方法：

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"来管理并行运行和结果排序。所花费的时间为86毫秒，这比原始汇总语句的一半还要少，并且仍然比另一个更快的汇总选项要少得多。

这是为什么？那么，MongoDB本身在执行常规查询时从查询引擎返回的“游标”中保存了一些特定的信息。部分信息是返回结果的“数量”。由于查询引擎已经完成了扫描并累计这个“匹配”的总数，所以这个数字是存在的，并且没有更多的工作需要获得“计数”。

相比之下，虽然聚合框架和$group在许多方面都很有用，但它以一种非常不同的方式做到了这一点。这在两种聚合方法之间的性能差异中部分显而易见，但主要的是基本的“查询引擎”以更高效的方式“计数”事物。

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

但这里的主要观点是，为了简单地“计数”一个属性的匹配值，在这种情况下可以这样做（并且true/false是一个好例子），那么最高性能的选项是运行“并行查询“正如本例中所示。性能改进通常会成为您“计数”的不同属性值数量的一个因素。

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

通用查询引擎中的优化结合同时发布.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); 
    }); 
}