mapReduce

Output to a Collection¶

out: <collectionName>

Output to a Collection with an Action¶

This option is only available when passing out a collection that already exists. This option is not available on secondary members of replica sets.

out: { <action>: <collectionName>
         [, db: <dbName>]
         [, sharded: <boolean> ]
         [, nonAtomic: <boolean> ] }

When you output to a collection with an action, the out has the following parameters:

• <action>: Specify one of the following actions:

  • replace

    Replace the contents of the <collectionName> if the collection with the <collectionName> exists.

  • merge

    Merge the new result with the existing result if the output collection already exists. If an existing document has the same key as the new result, overwrite that existing document.

  • reduce

    Merge the new result with the existing result if the output collection already exists. If an existing document has the same key as the new result, apply the reduce function to both the new and the existing documents and overwrite the existing document with the result.

• db:

Optional.The name of the database that you want the map-reduce operation to write its output. By default this will be the same database as the input collection.

• sharded:

Optional. If true and you have enabled sharding on output database, the map-reduce operation will shard the output collection using the _id field as the shard key.

• nonAtomic:

  2.2 新版功能.

  Optional. Specify output operation as non-atomic and is valid only for merge and reduce output modes which may take minutes to execute.

  If nonAtomic is true, the post-processing step will prevent MongoDB from locking the database; however, other clients will be able to read intermediate states of the output collection. Otherwise the map reduce operation must lock the database during post-processing.

Output Inline¶

Perform the map-reduce operation in memory and return the result. This option is the only available option for out on secondary members of replica sets.

out: { inline: 1 }

The result must fit within the maximum size of a BSON document.

返回客户ID的总价¶

Perform map-reduce operation on the orders collection to group by the cust_id, and for each cust_id, calculate the sum of the price for each cust_id:

1. Define the map function to process each input document:

   • In the function, this refers to the document that the map-reduce operation is processing.
   • The function maps the price to the cust_id for each document and emits the cust_id and price pair.

   var mapFunction1 = function() {
                          emit(this.cust_id, this.price);
                      };
   

2. Define the corresponding reduce function with two arguments keyCustId and valuesPrices:

   • The valuesPrices is an array whose elements are the price values emitted by the map function and grouped by keyCustId.
   • The function reduces the valuesPrice array to the sum of its elements.

   var reduceFunction1 = function(keyCustId, valuesPrices) {
                             return Array.sum(valuesPrices);
                         };
   

3. Perform the map-reduce on all documents in the orders collection using the mapFunction1 map function and the reduceFunction1 reduce function.

   db.orders.mapReduce(
                        mapFunction1,
                        reduceFunction1,
                        { out: "map_reduce_example" }
                      )
   

   This operation outputs the results to a collection named map_reduce_example. If the map_reduce_example collection already exists, the operation will replace the contents with the results of this map-reduce operation:

计算的订单数量，总数量，平均每个项目的数量¶

In this example you will perform a map-reduce operation on the orders collection, for all documents that have an ord_date value greater than 01/01/2012. The operation groups by the item.sku field, and for each sku calculates the number of orders and the total quantity ordered. The operation concludes by calculating the average quantity per order for each sku value:

1. Define the map function to process each input document:

   • In the function, this refers to the document that the map-reduce operation is processing.
   • For each item, the function associates the sku with a new object value that contains the count of 1 and the item qty for the order and emits the sku and value pair.

   var mapFunction2 = function() {
                          for (var idx = 0; idx < this.items.length; idx++) {
                              var key = this.items[idx].sku;
                              var value = {
                                            count: 1,
                                            qty: this.items[idx].qty
                                          };
                              emit(key, value);
                          }
                       };
   

2. Define the corresponding reduce function with two arguments keySKU and valuesCountObjects:

   • valuesCountObjects is an array whose elements are the objects mapped to the grouped keySKU values passed by map function to the reducer function.
   • The function reduces the valuesCountObjects array to a single object reducedValue that also contains the count and the qty fields.
   • In reducedValue, the count field contains the sum of the count fields from the individual array elements, and the qty field contains the sum of the qty fields from the individual array elements.

   var reduceFunction2 = function(keySKU, valuesCountObjects) {
                             reducedValue = { count: 0, qty: 0 };
   
                             for (var idx = 0; idx < valuesCountObjects.length; idx++) {
                                 reducedValue.count += valuesCountObjects[idx].count;
                                 reducedValue.qty += valuesCountObjects[idx].qty;
                             }
   
                             return reducedValue;
                         };
   

3. Define a finalize function with two arguments key and reducedValue. The function modifies the reducedValue object to add a computed field named average and returns the modified object:

   var finalizeFunction2 = function (key, reducedValue) {
   
                               reducedValue.average = reducedValue.qty/reducedValue.count;
   
                               return reducedValue;
                           };
   

4. Perform the map-reduce operation on the orders collection using the mapFunction2, reduceFunction2, and finalizeFunction2 functions.

   db.orders.mapReduce( mapFunction2,
                        reduceFunction2,
                        {
                          out: { merge: "map_reduce_example" },
                          query: { ord_date: { $gt: new Date('01/01/2012') } },
                          finalize: finalizeFunction2
                        }
                      )
   

   This operation uses the query field to select only those documents with ord_date greater than new Date(01/01/2012). Then it output the results to a collection map_reduce_example. If the map_reduce_example collection already exists, the operation will merge the existing contents with the results of this map-reduce operation:

For more information and examples, see the Map-Reduce page.