MongoDB中的MapReduce简介

MongoDB MapReduce

MapReduce是一种计算模型，简单的说就是将大批量的工作（数据）分解（MAP）执行，然后再将结果合并成最终结果（REDUCE）。这样做的好处是可以在任务被分解后，可以通过大量机器进行并行计算，减少整个操作的时间。

上面是MapReduce的理论部分，下面说实际的应用，下面以MongoDB MapReduce为例说明。

下面是MongoDB官方的一个例子：

> db.things.insert( { _id : 1, tags : ['dog', 'cat'] } );

> db.things.insert( { _id : 2, tags : ['cat'] } );

> db.things.insert( { _id : 3, tags : ['mouse', 'cat', 'dog'] } );

> db.things.insert( { _id : 4, tags : []  } );

> // map function

> map = function(){

...    this.tags.forEach(

...        function(z){

...            emit( z , { count : 1 } );

...        }

...    );

...};
> // reduce function

> reduce = function( key , values ){

...    var total = 0;

...    for ( var i=0; i<values.length; i++ )

...        total += values[i].count;

...    return { count : total };

...};
db.things.mapReduce(map,reduce,{out:'tmp'})

{

    "result" : "tmp",

    "timeMillis" : 316,

    "counts" : {

        "input" : 4,

        "emit" : 6,

        "output" : 3

    },

    "ok" : 1,

}

> db.tmp.find()

{ "_id" : "cat", "value" : { "count" : 3 } }

{ "_id" : "dog", "value" : { "count" : 2 } }

{ "_id" : "mouse", "value" : { "count" : 1 } }

例子很简单，计算一个标签系统中每个标签出现的次数。

这里面，除了emit函数之外，所有都是标准的js语法,这个emit函数是非常重要的，可以这样理解，当所有需要计算的文档（因为在mapReduce时，可以对文档进行过滤，接下来会讲到）执行完了map函数，map函数会返回key_values对，key即是emit中的第一个参数key，values是对应同一key的emit的n个第二个参数组成的数组。这个key_values会作为参数传递给reduce，分别作为第1.2个参数。

reduce函数的任务就是将key-values变成key-value，也就是把values数组变成一个单一的值value。当key-values中的values数组过大时，会被再切分成很多个小的key-values块，然后分别执行Reduce函数，再将多个块的结果组合成一个新的数组，作为Reduce函数的第二个参数，继续Reducer操作。可以预见，如果我们初始的values非常大，可能还会对第一次分块计算后组成的集合再次Reduce。这就类似于多阶的归并排序了。具体会有多少重，就看数据量了。

reduce一定要能被反复调用，不论是映射环节还是前一个简化环节。所以reduce返回的文档必须能作为reduce的第二个参数的一个元素。

（当书写Map函数时，emit的第二个参数组成数组成了reduce函数的第二个参数，而Reduce函数的返回值，跟emit函数的第二个参数形式要一致，多个reduce函数的返回值可能会组成数组作为新的第二个输入参数再次执行Reduce操作。）

MapReduce函数的参数列表如下：

db.runCommand(

 { mapreduce : <collection>,

   map : <mapfunction>,

   reduce : <reducefunction>

   [, query : <query filter object>]

   [, sort : <sort the query.  useful for optimization>]

   [, limit : <number of objects to return from collection>]

   [, out : <output-collection name>]

   [, keeptemp: <true|false>]

   [, finalize : <finalizefunction>]

   [, scope : <object where fields go into javascript global scope >]

   [, verbose : true]

 }

);

db.collection.mapReduce(

                         <map>,

                         <reduce>,

                         {

                           <out>,

                           <query>,

                           <sort>,

                           <limit>,

                           <keytemp>,

                           <finalize>,

                           <scope>,

                           <jsMode>,

                           <verbose>

                         }

                       )

1.mapreduce：指定要进行mapreduce处理的collection
2.map：map函数
3.reduce：reduce函数
4.out：输出结果的collection的名字，不指定会默认创建一个随机名字的collection（如果使用了out选项，就不必指定keeptemp：true了，因为已经隐含在其中了）
5.query：一个筛选条件，只有满足条件的文档才会调用map函数。（query。limit，sort可以随意组合）
6.sort：和limit结合的sort排序参数（也是在发往map函数前给文档排序），可以优化分组机制
7.limit：发往map函数的文档数量的上限（要是没有limit，单独使用sort的用处不大）
8.keytemp：true或false，表明结果输出到的collection是否是临时的，如果想在连接关闭后仍然保留这个集合，就要指定keeptemp为true，如果你用的是MongoDB的mongo客户端连接，那必须exit后才会删除。如果是脚本执行，脚本退出或调用close会自动删除结果collection
9.finalize：是函数，它会在执行完map、reduce后再对key和value进行一次计算并返回一个最终结果，这是处理过程的最后一步，所以finalize就是一个计算平均数，剪裁数组，清除多余信息的恰当时机
10.scope：javascript代码中要用到的变量，在这里定义的变量在map，reduce，finalize函数中可见
11.verbose：用于调试的详细输出选项，如果想看MpaReduce的运行过程，可以设置其为true。也可以print把map，reduce，finalize过程中的信息输出到服务器日志上。

执行MapReduce函数返回的文档结构如下：

  { result : <collection_name>,

    timeMillis : <job_time>,
    counts : {
               input : <number of objects scanned>,
               emit : <number of times emit was called>,
               output : <number of items in output collection>
     } ,
     ok : <1_if_ok>,
     [, err : <errmsg_if_error>]
}

1.result：储存结果的collection的名字,这是个临时集合，MapReduce的连接关闭后自动就被删除了。
2.timeMillis：执行花费的时间，毫秒为单位
3.input：满足条件被发送到map函数的文档个数
4.emit：在map函数中emit被调用的次数，也就是所有集合中的数据总量
5.ouput：结果集合中的文档个数（count对调试非常有帮助）
6.ok：是否成功，成功为1
7.err：如果失败，这里可以有失败原因，不过从经验上来看，原因比较模糊，作用不大

java代码执行MapReduce的方法：

public void MapReduce() {

        Mongo mongo = new Mongo("localhost",27017);

        DB db = mongo.getDB("qimiguangdb");

        DBCollection coll = db.getCollection("collection1");

       

        String map = "function() { emit(this.name, {count:1});}";

                                                                                                              

   

        String reduce = "function(key, values) {";  

        reduce=reduce+"var total = 0;";  

        reduce=reduce+"for(var i=0;i<values.length;i++){total += values[i].count;}";  

        reduce=reduce+"return {count:total};}";  

          

        String result = "resultCollection";  

          

        MapReduceOutput mapReduceOutput = coll.mapReduce(map,  

                reduce.toString(), result, null);  

        DBCollection resultColl = mapReduceOutput.getOutputCollection();  

        DBCursor cursor= resultColl.find();  

        while (cursor.hasNext()) {  

            System.out.println(cursor.next());  

        }  

    }