mapReduce

Requirements for the map Functionmap函数要求

The map function is responsible for transforming each input document into zero or more documents. map函数负责将每个输入文档转换为零个或多个文档。It can access the variables defined in the scope parameter, and has the following prototype:它可以访问scope参数中定义的变量，并具有以下原型：

function() {
   ...
   emit(key, value);
}

The map function has the following requirements:map函数有以下要求：

• In the map function, reference the current document as this within the function.在map函数中，在函数中将当前文档引用为this。
• The map function should not access the database for any reason.map函数不应出于任何原因访问数据库。
• The map function should be pure, or have no impact outside of the function (i.e. side effects.)map函数应该是纯函数，或者在函数之外没有影响（即副作用）
• The map function may optionally call emit(key,value) any number of times to create an output document associating key with value.map函数可以可选地调用emit(key,value)任意次数，以创建将key与value关联的输出文档。
• In MongoDB 4.2 and earlier, a single emit can only hold half of MongoDB's maximum BSON document size. 在MongoDB 4.2及更早版本中，单个发出只能容纳MongoDB最大BSON文档大小的一半。MongoDB removes this restriction starting in version 4.4.MongoDB从4.4版开始删除此限制。

• Starting in MongoDB 4.4, mapReduce no longer supports the deprecated BSON type JavaScript code with scope (BSON type 15) for its functions. The map function must be either BSON type String (BSON type 2) or BSON type JavaScript (BSON type 13). To pass constant values which will be accessible in the map function, use the scope parameter.

  The use of JavaScript code with scope for the map function has been deprecated since version 4.2.1.自4.2.1版以来，不推荐对map函数使用带有scope的JavaScript代码。

The following map function will call emit(key,value) either 0 or 1 times depending on the value of the input document's status field:

function() {
    if (this.status == 'A')
        emit(this.cust_id, 1);
}

The following map function may call emit(key,value) multiple times depending on the number of elements in the input document's items field:

function() {
    this.items.forEach(function(item){ emit(item.sku, 1); });
}

Requirements for the reduce Function

The reduce function has the following prototype:

function(key, values) {
   ...
   return result;
}

The reduce function exhibits the following behaviors:

• The reduce function should not access the database, even to perform read operations.
• The reduce function should not affect the outside system.
• MongoDB will not call the reduce function for a key that has only a single value. The values argument is an array whose elements are the value objects that are "mapped" to the key.
• MongoDB can invoke the reduce function more than once for the same key. In this case, the previous output from the reduce function for that key will become one of the input values to the next reduce function invocation for that key.
• The reduce function can access the variables defined in the scope parameter.
• The inputs to reduce must not be larger than half of MongoDB's maximum BSON document size. This requirement may be violated when large documents are returned and then joined together in subsequent reduce steps.

• Starting in MongoDB 4.4, mapReduce no longer supports the deprecated BSON type JavaScript code with scope (BSON type 15) for its functions. The reduce function must be either BSON type String (BSON type 2) or BSON type JavaScript (BSON type 13). To pass constant values which will be accessible in the reduce function, use the scope parameter.

  The use of JavaScript code with scope for the reduce function has been deprecated since version 4.2.1.

Because it is possible to invoke the reduce function more than once for the same key, the following properties need to be true:

• the type of the return object must be identical to the type of the value emitted by the map function.

• the reduce function must be associative. The following statement must be true:

  reduce(key, [ C, reduce(key, [ A, B ]) ] ) == reduce( key, [ C, A, B ] )

• the reduce function must be idempotent. Ensure that the following statement is true:

  reduce( key, [ reduce(key, valuesArray) ] ) == reduce( key, valuesArray )

• the reduce function should be commutative: that is, the order of the elements in the valuesArray should not affect the output of the reduce function, so that the following statement is true:

  reduce( key, [ A, B ] ) == reduce( key, [ B, A ] )

Requirements for the finalize Function

The finalize function has the following prototype:

function(key, reducedValue) {
   ...
   return modifiedObject;
}

The finalize function receives as its arguments a key value and the reducedValue from the reduce function. Be aware that:

• The finalize function should not access the database for any reason.
• The finalize function should be pure, or have no impact outside of the function (i.e. side effects.)
• The finalize function can access the variables defined in the scope parameter.

• Starting in MongoDB 4.4, mapReduce no longer supports the deprecated BSON type JavaScript code with scope (BSON type 15) for its functions. The finalize function must be either BSON type String (BSON type 2) or BSON type JavaScript (BSON type 13). To pass constant values which will be accessible in the finalize function, use the scope parameter.

  The use of JavaScript code with scope for the finalize function has been deprecated since version 4.2.1.

out Options选项

You can specify the following options for the out parameter:可以为out参数指定以下选项：

out: <collectionName>

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

out: { inline: 1 }

Return the Total Price Per Customer返回每个客户的总价

Perform the map-reduce operation on the orders collection to group by the cust_id, and 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.在函数中，this引用map-reduce操作正在处理的文档。
   • The function maps the price to the cust_id for each document and emits the cust_id and price.

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

2. Define the corresponding reduce function with two arguments keyCustId and valuesPrices:使用两个参数keyCustId和valuesPrices定义相应的reduce函数：

   • 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 map-reduce on all documents in the orders collection using the mapFunction1 map function and the reduceFunction1 reduce function:使用mapFunction1映射函数和reduceFunction1-reduce函数对orders集合中的所有文档执行映射缩减：

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

   This operation outputs the results to a collection named map_reduce_example. 此操作将结果输出到名为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.如果map_reduce_example集合已经存在，则该操作将用此map-reduce操作的结果替换内容。

4. Query the map_reduce_example collection to verify the results:

   db.map_reduce_example.find().sort( { _id: 1 } )

   The operation returns these documents:该操作将返回以下文档：

   { "_id" : "Ant O. Knee", "value" : 95 }
   { "_id" : "Busby Bee", "value" : 125 }
   { "_id" : "Cam Elot", "value" : 60 }
   { "_id" : "Don Quis", "value" : 155 }

db.orders.aggregate([
   { $group: { _id: "$cust_id", value: { $sum: "$price" } } },
   { $out: "agg_alternative_1" }
])

Calculate Order and Total Quantity with Average Quantity Per Item用每个项目的平均数量计算订单和总数量

In the following example, you will see a map-reduce operation on the orders collection for all documents that have an ord_date value greater than or equal to 2020-03-01.在下面的示例中，您将看到ord_date值大于或等于2020-03-01的所有文档的orders集合上的map-reduce操作。

The operation in the example:示例中的操作：

1. Groups by the item.sku field, and calculates the number of orders and the total quantity ordered for each sku.按item.sku字段分组，并计算每个sku的订单数量和总订单数量。
2. Calculates the average quantity per order for each sku value and merges the results into the output collection.计算每个sku值的每个订单的平均数量，并将结果合并到输出集合中。

When merging results, if an existing document has the same key as the new result, the operation overwrites the existing document. 合并结果时，如果现有文档与新结果具有相同的键，则该操作将覆盖现有文档。If there is no existing document with the same key, the operation inserts the document.如果没有具有相同键的现有文档，则该操作将插入该文档。

Example steps:

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.在函数中，this是指map reduce操作正在处理的文档。
   • 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 (stored in the key) and the value.

    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 countObjVals:使用两个参数keySKU和countObjVals定义相应的reduce函数：

   • countObjVals is an array whose elements are the objects mapped to the grouped keySKU values passed by map function to the reducer function.是一个数组，其元素是映射到由map函数传递给reducer函数的分组keySKU值的对象。
   • The function reduces the countObjVals array to a single object reducedValue that contains the count and the qty fields.
   • In reducedVal, 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, countObjVals) {
      reducedVal = { count: 0, qty: 0 };
      for (var idx = 0; idx < countObjVals.length; idx++) {
          reducedVal.count += countObjVals[idx].count;
          reducedVal.qty += countObjVals[idx].qty;
      }
      return reducedVal;
   };

3. Define a finalize function with two arguments key and reducedVal. 定义一个带有两个参数key和reducedVal的finalize函数。The function modifies the reducedVal object to add a computed field named avg and returns the modified object:该函数修改reducedVal对象以添加名为avg的计算字段，并返回修改后的对象：

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

4. Perform the map-reduce operation on the orders collection using the mapFunction2, reduceFunction2, and finalizeFunction2 functions:使用mapFunction2、reduceFunction3和finalizeFunction4函数对orders集合执行map-reduce操作：

   db.orders.mapReduce(
      mapFunction2,
      reduceFunction2,
      {
        out: { merge: "map_reduce_example2" },
        query: { ord_date: { $gte: new Date("2020-03-01") } },
        finalize: finalizeFunction2
      }
    );

   This operation uses the query field to select only those documents with ord_date greater than or equal to new Date("2020-03-01"). Then it outputs the results to a collection map_reduce_example2.

   If the map_reduce_example2 collection already exists, the operation will merge the existing contents with the results of this map-reduce operation. 如果map_reduce_example2集合已经存在，则该操作将将现有内容与此map-reduce操作的结果合并。That is, if an existing document has the same key as the new result, the operation overwrites the existing document. 也就是说，如果现有文档具有与新结果相同的键，则该操作将覆盖现有文档。If there is no existing document with the same key, the operation inserts the document.如果没有具有相同键的现有文档，则该操作将插入该文档。

5. Query the map_reduce_example2 collection to verify the results:查询map_reduce_example2集合以验证结果：

   db.map_reduce_example2.find().sort( { _id: 1 } )

   The operation returns these documents:该操作将返回以下文档：

   { "_id" : "apples", "value" : { "count" : 4, "qty" : 35, "avg" : 8.75 } }
   { "_id" : "carrots", "value" : { "count" : 2, "qty" : 15, "avg" : 7.5 } }
   { "_id" : "chocolates", "value" : { "count" : 3, "qty" : 15, "avg" : 5 } }
   { "_id" : "oranges", "value" : { "count" : 7, "qty" : 63, "avg" : 9 } }
   { "_id" : "pears", "value" : { "count" : 1, "qty" : 10, "avg" : 10 } }

db.orders.aggregate( [
   { $match: { ord_date: { $gte: new Date("2020-03-01") } } },
   { $unwind: "$items" },
   { $group: { _id: "$items.sku", qty: { $sum: "$items.qty" }, orders_ids: { $addToSet: "$_id" } }  },
   { $project: { value: { count: { $size: "$orders_ids" }, qty: "$qty", avg: { $divide: [ "$qty", { $size: "$orders_ids" } ] } } } },
   { $merge: { into: "agg_alternative_3", on: "_id", whenMatched: "replace",  whenNotMatched: "insert" } }
] )