Question

我有以下数据集：

{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"},

我确实找到了一种使用aggregate / group获取company和employee_count的方法但是，我找不到使用相同查询添加randomemployee的方法。

我的聚合：

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

我开始了另一个Sample函数：

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)
    },
    ])

Answer 1

有一种方法涉及一个查询，它可能是接近但不是高效（因为它使用 $unwind ）并且不会给你所需的结果（仅过滤公司）：

var pipeline = [
    {
        "$group": {
            "_id": "$company",
            "total": { "$sum": 1 },
            "employees": { "$push": "$employee" }
        }
    },
    {
        "$project": {
            "_id": 0,
            "company": "$_id",
            "employee_count": "$total"
            "randomemployee": "$employees"
        }
    },
    { "$unwind": "$randomemployee" },
    { "$match": { "company": arg } },
    { "$sample": { size: 1 } }
];
collection.aggregate(pipeline, function(err, result){
    console.log(result);
});

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

为了让所有不同的公司，每个公司的员工数量，每个公司的随机员工考虑使用 async.waterfall() 功能，其中第一个任务返回与所有不同公司的汇总结果每家公司的员工人数。

第二项任务使用上面第1项中的结果来使用 async.forEachOf() 进行迭代。这允许您为每个项目执行异步任务，并且当他们完成所有操作时执行其他操作。对于阵列中的每个文档，运行使用 $sample 运算符的聚合操作来获取指定公司的随机文档。对于每个结果，使用随机员工创建一个额外的字段，并将其推送到一个数组，其中包含您可以在每个任务结束时访问的最终结果。

下面显示了这种方法：

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

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

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

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

Answer 2

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" }

Mongodb：$ group

2 个答案: