mapReduce¶

On this page

Examples

mapReduce¶

The mapReduce command allows you to run map-reduce aggregation operations over a collection. The mapReduce command has the following prototype form:

copy

db.runCommand(
               {
                 mapReduce: <collection>,
                 map: <function>,
                 reduce: <function>,
                 out: <output>,
                 query: <document>,
                 sort: <document>,
                 limit: <number>,
                 finalize: <function>,
                 scope: <document>,
                 jsMode: <boolean>,
                 verbose: <boolean>
               }
             )

Pass the name of the collection to the mapReduce command (i.e. <collection>) to use as the source documents to perform the map reduce operation. The command also accepts the following parameters:

Parameters:

map –
A JavaScript function that associates or “maps” a value with a key and emits the key and value pair.

The map function processes every input document for the map-reduce operation. However, the map function can call emit any number of times, including 0, for each input document. The map-reduce operation groups the emitted value objects by the key and passes these groupings to the reduce function. See below for requirements for the map function.
reduce –
A JavaScript function that “reduces” to a single object all the values associated with a particular key.

The reduce function accepts two arguments: key and values. The values argument is an array whose elements are the value objects that are “mapped” to the key. See below for requirements for the reduce function.
out –

New in version 1.8.

Specifies the location of the result of the map-reduce operation. You can output to a collection, output to a collection with an action, or output inline. You may output to a collection when performing map reduce operations on the primary members of the set; on secondary members you may only use the inline output.
query – Optional. Specifies the selection criteria using query operators for determining the documents input to the map function.
sort – Optional. Sorts the input documents. This option is useful for optimization. For example, specify the sort key to be the same as the emit key so that there are fewer reduce operations.
limit – Optional. Specifies a maximum number of documents to return from the collection.
finalize –
Optional. A JavaScript function that follows the reduce method and modifies the output.

The finalize function receives two arguments: key and reducedValue. The reducedValue is the value returned from the reduce function for the key.
scope (document) – Optional. Specifies global variables that are accessible in the map , reduce and the finalize functions.
jsMode (Boolean) –

New in version 2.0.

Optional. Specifies whether to convert intermediate data into BSON format between the execution of the map and reduce functions.

If false:
- Internally, MongoDB converts the JavaScript objects emitted by the map function to BSON objects. These BSON objects are then converted back to JavaScript objects when calling the reduce function.
- The map-reduce operation places the intermediate BSON objects in temporary, on-disk storage. This allows the map-reduce operation to execute over arbitrarily large data sets.
If true:
- Internally, the JavaScript objects emitted during map function remain as JavaScript objects. There is no need to convert the objects for the reduce function, which can result in faster execution.
- You can only use jsMode for result sets with fewer than 500,000 distinct key arguments to the mapper’s emit() function.
The jsMode defaults to false.
verbose (Boolean) – Optional. Specifies whether to include the timing information in the result information. The verbose defaults to true to include the timing information.

The following is a prototype usage of the mapReduce command:

copy

var mapFunction = function() { ... };
var reduceFunction = function(key, values) { ... };

db.runCommand(
               {
                 mapReduce: 'orders',
                 map: mapFunction,
                 reduce: reduceFunction,
                 out: { merge: 'map_reduce_results', db: 'test' },
                 query: { ord_date: { $gt: new Date('01/01/2012') } }
               }
             )

Important

When connected to a mongos for a sharded cluster, to use the mapReduce directly, you must specify the all-lower-case form of the command (i.e.``mapreduce``.)

Examples¶

In the mongo shell, the db.collection.mapReduce() method is a wrapper around the mapReduce command. The following examples use the db.collection.mapReduce() method:

Consider the following map-reduce operations on a collection orders that contains documents of the following prototype:

copy

{
     _id: ObjectId("50a8240b927d5d8b5891743c"),
     cust_id: "abc123",
     ord_date: new Date("Oct 04, 2012"),
     status: 'A',
     price: 25,
     items: [ { sku: "mmm", qty: 5, price: 2.5 },
              { sku: "nnn", qty: 5, price: 2.5 } ]
}

Return the Total Price Per Customer 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:

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.
copy
```
var mapFunction1 = function() {
                       emit(this.cust_id, this.price);
                   };
```
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.
copy
```
var reduceFunction1 = function(keyCustId, valuesPrices) {
                          return Array.sum(valuesPrices);
                      };
```
Perform the map-reduce on all documents in the orders collection using the mapFunction1 map function and the reduceFunction1 reduce function.
copy
```
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:

Calculate the Number of Orders, Total Quantity, and Average Quantity Per Item¶

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:

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.

copy

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

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.

copy

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

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:

copy

var finalizeFunction2 = function (key, reducedValue) {

                            reducedValue.average = reducedValue.qty/reducedValue.count;

                            return reducedValue;
                        };

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

copy

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.