Javascript Mongodb：在$group之后使用$sample

我有以下数据集：

{company:"One",  employee:"John"},
{company:"One",  employee:"Mike"},  
{company:"One",  employee:"Donald"},  
{company:"One",  employee:"Mickey"},  
{company:"Two",  employee:"Johnny"},  
{company:"Two",  employee:"David"}, 

理想情况下，我希望查询返回所有不同的公司、每个公司的员工数量、每个公司的随机员工

{Company: "One" , employee_count=4, randomemployee="Donald"},
{Company: "Two" , employee_count=2, randomemployee="David"},

我确实找到了一种使用聚合/组获取公司和员工数量的方法 但是，我没有找到一种方法来添加具有相同查询的随机雇员

我的汇总：

function aggr (collection,cb){
   collection.aggregate(([{$group:{_id:'$company',total:{$sum:1}}},{$sort:{total:-1}}]),function(err, l1){
   cb(null, l1)
})
}

我开始了另一个示例函数：

function onesample (collection,arg,cb){
    collection.aggregate(([{ $match: { "company": arg }},{ $sample: { size: 1 }}]),function(err, item){
   cb(null, item[0].employee)
})
}

但我失去了自己的回调和循环。 在一个查询中有什么优雅的方法可以做到这一点吗

非常感谢

根据您的回答，我尝试了以下代码。 我对async.foreachof的回调有一个问题，似乎在进入下一步之前还没有完成：有什么线索吗

var async = require("async");   
var MongoClient = require('mongodb').MongoClient;
var assert = require('assert');
var url = 'mongodb://localhost:27017/eyc0';



async.waterfall ([
     function(cb) { 
            MongoClient.connect(url, function(err, db) {
            cb(null,db)
             })
    },
     function (db, cb) {
             db.collection('kodes', function(err, coll) {
            cb(null,db,coll)
             })
    },
      function (db,coll, cb) {
                 var pipeline = [
                {"$group": {"_id": "$ouat","total": { "$sum": 1}}},
                {"$sort":{"total":-1} },
                {"$project":{"_id": 0,"total":1,"company": "$_id"}}];

                coll.aggregate(pipeline).toArray(function(err, dlist){
                cb(null,db,coll,dlist)
                })
    },
        function (db,coll,dlist, cb) {
            // console.log(dlist)
            cb(null,db,coll,dlist)
    },
          function (db,coll,dlist, cb) {
             var dlist2 = []
                async.forEachOf( 
                    dlist,
                    function(item, key, cb){
                        var pipeline = [{ "$match": { "ouat": item.company } },{ "$sample": { size: 1 } }];
                        coll.aggregate(pipeline, function (err, data) {
                        item["randref"] = data[0].code;
                        console.log(item.company)
                        dlist2.push(item)
                        cb()
                    });

                    }
                );
                 cb(null,db,coll,dlist,dlist2);

    },
        function (db,coll,dlist,dlist2, cb) {
            console.log(dlist2)
            console.log(dlist)
    },
    ])

---

有一种方法涉及一个查询，它可能很接近，但性能不如（它使用的是），并且不会给您提供所需的结果（只有经过筛选的公司）：

但是，对于使用来自多个查询的回调的解决方案，使用模块可以轻松处理这一问题

为获取所有不同的公司，每个公司的雇员数量，每个公司的随机雇员考虑使用“强”< /强>函数，其中第一个任务返回聚合结果，每个公司有不同的公司和雇员数量。p> 第二个任务使用上面taks 1的结果，使用进行迭代。这允许您为每个项目执行异步任务，并在完成所有任务后执行其他操作。对于数组中的每个文档，运行聚合操作，该操作使用操作符获取指定公司的随机文档。对于每个结果，使用随机雇员创建一个额外字段，并将其推送到一个数组中，该数组包含最终结果，您可以在每个任务结束时访问这些结果

下面显示了这种方法：

var async = require("async");    
async.waterfall([

        // Load full aggregation results (won't be called before task 1's "task callback" has been called)
        function(callback) {
            var pipeline = [
                {
                    "$group": {
                        "_id": "$company",
                        "total": { "$sum": 1 }                      
                    }
                },
                {
                    "$project": {
                        "_id": 0,
                        "company": "$_id",                      
                        "employee_count": "total"
                    }
                }
            ];
            collection.aggregate(pipeline, function(err, results){
                if (err) return callback(err);
                callback(results);
            });
        },

        // Load random employee for each of the aggregated results in task 1
        function(results, callback) {
            var docs = []
            async.forEachOf(                
                results,
                function(value, key, callback) {                    
                    var pipeline = [                                
                        { "$match": { "company": value.company } },
                        { "$sample": { size: 1 } }
                    ];
                    collection.aggregate(pipeline, function (err, data) {
                        if (err) return callback(err);
                        value["randomemployee"] = data[0].employee;
                        docs.push(value);
                        callback();
                    });
                },
                function(err)
                    callback(null, docs);
                }
            );
        },
    ], function(err, result) { 
        if (err) return next(err);            
        console.log(JSON.stringify(result, null, 4));
    }
);

---

使用函数，如果您需要按特定顺序执行一组异步函数，这将非常有用

如果希望将所有不同的公司及其员工计数作为一个结果，将另一个随机员工计数作为另一个结果，请考虑以下方法：

var async = require("async"),
    locals = {},
    company = "One";
async.series([
        // Load random company
        function(callback) {
            var pipeline = [                                
                { "$match": { "company": company } },
                { "$sample": { size: 1 } }
            ];
            collection.aggregate(pipeline, function(err, result){
                if (err) return callback(err);                
                locals.randomcompany = result[0];
                callback();
            });            
        },
        // Load full aggregation results (won't be called before task 1's "task callback" has been called)
        function(callback) {
            var pipeline = [
                {
                    "$group": {
                        "_id": "$company",
                        "total": { "$sum": 1 }                      
                    }
                },
                {
                    "$project": {
                        "_id": 0,
                        "company": "$_id",                      
                        "employee_count": "total"
                    }
                }
            ];
            collection.aggregate(pipeline, function(err, result){
                if (err) return callback(err);                
                locals.aggregation = result;
                callback();
            });
        }
    ], function(err) { //This function gets called after the two tasks have called their "task callbacks"
        if (err) return next(err);
        //Here locals will be populated with 'randomcompany' and 'aggregation'
        console.log(JSON.stringify(locals, null, 4));
    }
);

---

似乎有用

两个结果：

{ "employee_count" : 4, "Company" : "One", "randomemployee" : "Mike" }
{ "employee_count" : 2, "Company" : "Two", "randomemployee" : "Johnny" }

{ "employee_count" : 4, "Company" : "One", "randomemployee" : "Mickey" }
{ "employee_count" : 2, "Company" : "Two", "randomemployee" : "David" }

---

如何获得

randomemployee

？我尝试使用$sample：它确实有效，但是我想使用新引入的$sample@LittleBigFrog

$sample

对于您想要实现的目标来说似乎不是一个好的用例，并且增加了不必要的开销。这里更好的改进是使用

$addToSet

而不是

$push

来创建“独特”的员工列表。另外，最好在后期处理中从该不同的列表中获取随机样本，而不是在聚合管道中强制执行。仅仅因为你能，并不意味着你应该。最有效的方法是在后期处理中完成。Blakes Seven是对的，我编辑了代码，将$push替换为$addToSet，假设每个员工都有不同的名字（这在这个问题中似乎很自然），非常感谢，但我澄清了预期的结果：“我想要一个返回所有不同公司、每个公司的员工数量、每个公司的随机员工数的查询”。@LittleBifRog我已经用另一种方法更新了我的答案。非常感谢。我可以问第二个答案是否需要使用$project吗？：{“$project”：{”{id：0，“公司”：“$\u id”，“员工人数”：“total”}您需要具有此结构的文档

{company:“One”，employee\u count=4，randomemployee=“Donald”}

在您的结果中，对吗？

$project

操作符只执行此操作，但如果您对结果文档中的

\u id

键作为公司字段表示满意，则无需执行此操作。该函数迭代值数组，并对每个值执行聚合管道。

db.comp.aggregate([
{$group:{_id:'$company',emp:{$addToSet:'$employee'}}},
{$project:{emp:1,employee_count:{'$size':'$emp'}, 
                 randomvalue:{'$literal':Math.random()}}},
{$project:{emp:1,employee_count:1,
           randomposition:{'$floor':
                    {'$multiply':['$randomvalue', '$employee_count']}}}},
{$project:{'Company':'$_id', _id:0, employee_count:1,  
            randomemployee:{'$arrayElemAt':['$emp','$randomposition']}}},
{$sort:{Company:1}} ])

{ "employee_count" : 4, "Company" : "One", "randomemployee" : "Mike" }
{ "employee_count" : 2, "Company" : "Two", "randomemployee" : "Johnny" }

{ "employee_count" : 4, "Company" : "One", "randomemployee" : "Mickey" }
{ "employee_count" : 2, "Company" : "Two", "randomemployee" : "David" }