对内部文档mongodb进行排序的mapreduce

您的PHP背景似乎正在显示。您表示的数据结构未以典型的JSON表示法显示数组，但是在mapReduce代码中注意到了对“推”的调用，至少在“临时文档”中，这些值实际上是数组。您似乎已经以相同的方式“标注”了它们，因此假设它们是合理的。

实际阵列是在此处存储的最佳选择，特别是考虑到所需的结果。因此，即使没有，您的原始文档也应该像这样，因为它们将在shell中表示：

{
   "_id": ObjectId("53b394d6f9c747e33d19234d"),
   "autoUid": "ffc74819-c844-4d61-8657-b6ab09617271"
   "createDate": ISODate("2014-07-02T05:12:54.171Z"),
   "account_details": {
     "tag_cloud": [
       "FIFA World Cup 2014",
       "Brazil",
       "Football",
       "Argentina",
       "Belgium"
     ]
   }
}

使用类似的文档，或者如果您将其更改为类似的文档，那么执行此操作的正确工具就是聚合框架。它可以在本机代码中运行，并且不需要JavaScript解释，因此速度更快。

获得最终结果的聚合语句如下所示：

db.collection.aggregate([

    // Unwind the array to "de-normalize"
    { "$unwind": "$account_details.tag_cloud" },

    // Group by "autoUid" and "tag", summing totals
    { "$group": {
        "_id": {
            "autoUid": "$autoUid",
            "tag": "$account_details.tag_cloud"                
        },
        "total": { "$sum": 1 }
    }},

    // Sort the results to largest count per user
    { "$sort": { "_id.autoUid": 1, "total": -1 }

    // Group to a single user with an array of "tags" if you must
    { "$group": {
        "_id": "$_id.autoUid",
        "tags": { 
            "$push": {
                "tag": "$_id.tag",
                "total": "$total"
            }
        }
    }}
])

输出略有不同，但处理起来简单得多，速度也快得多：

{
    "_id": "ffc74819-c844-4d61-8657-b6ab09617271",
    "tags": [
        { "tag": "Narendra Modi", "total": 2 },
        { "tag": "Prakash Javadekar", "total": 1 },
        { "tag": "Shastri Bhawan", "total": 1 },
        { "tag": "Prime Minister's Office (PMO)", "total": 1 },  
        { "tag": "explosion", "total": 1 },
        { "tag": "GAIL", "total":  1 },
        { "tag": "Andhra Pradesh", "total": 1 },
        { "tag": "N Chandrababu Naidu", "total": 1 },
        { "tag": "Prime Minister", "total": 1 },
        { "tag": "Bharatiya Janata Party (BJP)", "total": 1 },
        { "tag": "Government", "total": 1 }
    ]
}

还可以根据用户的“标签相关性得分”对标签进行排序，以确保达到良好的效果，但是您可以根据实际情况考虑删除该标签，甚至删除最后两个阶段。

到目前为止，最好的选择仍然是。了解如何使用聚合框架。如果您的“输出”仍然是“大”（超过16MB），那么请尝试迁移到MongoDB 2.6或更高版本。聚合语句可以产生一个“游标”，该游标可以被迭代而不是一次提取所有结果。也有$out像mapReduce一样可以创建集合的运算符。

如果您的数据实际上是子文档的“哈希”格式，则您要对此表示法表示（遵循数组的PHP“转储”约定），则您需要使用mapReduce，因为聚合框架无法遍历“散列键”的表示方式。不是最佳的结构，如果是这种情况，则应更改它。

您的方法仍然有一些更正，实际上，这实际上是对最终结果的一步操作。同样，最终输出将包含“标签”的“数组”，因为将“数据”用作“键”名称确实不是一个好习惯：

db.collection.mapReduce(
    function() {

        var tag_cloud = this.account_details.tag_cloud; 
        var obj = {};

        for ( var k in tag_cloud ) {
            obj[tag_cloud[k]] = 1; 
        }

        emit( this.autoUid, obj );

    },
    function(key,values) {

        var reduced = {};

        // Combine keys and totals
        values.forEach(function(value) {
            for ( var k in value ) {
                if (!reduced.hasOwnProperty(k))
                    reduced[k] = 0;
                reduced[k] += value[k];
            }
        });

        return reduced;
    },
    { 
        "out": { "inline": 1 }, 
        "finalize": function(key,value) {

            var output = [];

            // Mapped to array for output
            for ( var k in value ) {
                output.push({
                    "tag": k,
                    "total": value[k]
                });                    
            }

            // Even sorted just the same
            return output.sort(function(a,b) {
                return ( a.total < b.total ) ? -1 : ( a.total > b.total ) ? 1 : 0;
            });

        }
    }
)

或者，如果它实际上是原始文档中“标签”的“数组”，但是最终输出将太大，并且您无法升级到最新版本，那么初始数组处理将有所不同：

db.collection.mapReduce(
    function() {

        var tag_cloud = this.account_details.tag_cloud; 
        var obj = {};

        tag_cloud.forEach(function(tag) {
            obj[tag] = 1; 
        });

        emit( this.autoUid, obj );

    },
    function(key,values) {

        var reduced = {};

        // Combine keys and totals
        values.forEach(function(value) {
            for ( var k in value ) {
                if (!reduced.hasOwnProperty(k))
                    reduced[k] = 0;
                reduced[k] += value[k];
            }
        });

        return reduced;
    },
    { 
        "out": { "replace": "newcollection" },
        "finalize": function(key,value) {

            var output = [];

            // Mapped to array for output
            for ( var k in value ) {
                output.push({
                    "tag": k,
                    "total": value[k]
                });                    
            }

            // Even sorted just the same
            return output.sort(function(a,b) {
                return ( a.total < b.total ) ? -1 : ( a.total > b.total ) ? 1 : 0;
            });

        }
    }
)

一切基本上都遵循相同的原则以达到最终结果：

1. 使用“用户”和分组密钥将其归一化为“用户”和“标签”组合
2. 将每个用户的结果与“标记”值的总和相结合。

在这里的mapReduce方法中，除了比您看上去想的要干净以外，这里要考虑的另一个主要问题是reducer需要“输出”与映射器完全相同的“输入”。原因实际上是有据可查的，因为实际上可以多次调用“ reducer”，基本上是“ reducing”输出，而该输出已经通过reduce处理。

通常，这就是mapReduce处理“大输入”的方式，其中给定的“键”有很多值，而“归约器”一次只能处理这么多值。例如，一个缩减器实际上可能只获取使用同一密钥发出的30个左右的文档，将这30个文档中的两组缩减为2个文档，然后最终将单个密钥还原为单个输出。

这里的最终结果与上面显示的其他输出相同，但mapReduce的区别在于所有内容都在“值”键下，因为这就是它的工作方式。

因此，有两种方法可以根据您的数据进行操作。尽量使用聚合框架，因为它要快得多，现代版本可以消耗和输出与mapReduce一样多的数据。