db.collection.mapReduce（）

在本页面

• map功能要求

• reduce功能要求

• 选项

• finalize功能要求

• Map-Reduce 例子

• 输出

• 附加信息

db.collection. mapReduce( map，reduce，{<out>，<query>，<sort>，<limit>，<finalize>，<scope>，<jsMode>，<verbose>})

注意

从4.2版开始，MongoDB弃用：

• 地图-reduce选项来创建一个新的分片集合以及使用的分片供选择的map-reduce。要输出到分片集合，请首先创建分片集合。MongoDB 4.2还不建议替换现有分片集合。
• nonAtomic：false选项的显式规范。

db.collection.mapReduce()方法为MapReduce命令提供了包装。

注意

视图不支持 map-reduce 操作。

db.collection.mapReduce()具有以下语法：

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

db.collection.mapReduce()采用以下参数：

下表描述了db.collection.mapReduce()可以接受的其他参数。

注意

map-reduce operations， group 命令和$where 运算表达式无法访问 mongo shell 中可用的某些 global 函数或 properties，例如 db。 可用的 PropertiesAvailable 函数

以下JavaScript函数和属性可用于 和 运算符表达式：map-reduce operations、$where

map功能要求

map function 负责将每个输入文档转换为零个或多个文档。它可以访问scope参数中定义的变量，并具有以下原型：

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

map function 具有以下要求：

• 在map function 中，在 function 中将当前文档作为this引用。
• map function 不应出于任何原因访问数据库。
• map function 应该是纯的，或者在 function 之外没有影响(即：side effects.)
• 单个发射只能容纳 MongoDB 的最大 BSON 文件大小的一半。
• map function 可以选择多次调用emit(key,value)来创建一个将key与value相关联的输出文档。
• 在MongoDB 4.2和更早版本中，单个发射只能容纳MongoDB 最大BSON文档大小的一半。从版本4.4开始，MongoDB删除了此限制。
• 从MongoDB 4.4开始，它的功能mapReduce不再支持范围（即BSON类型15）的已弃用JavaScript 。该map 函数必须是BSON类型的String（即BSON类型2）或BSON类型的JavaScript（即BSON类型13）。要确定变量的范围，请使用 scope参数。

map自版本4.2.1起，该功能不建议在范围内使用JavaScript

以下map function 将调用emit(key,value) 0 或 1 次，具体取决于输入文档的status字段的 value：

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

以下map function 可能会多次调用emit(key,value)，具体取决于输入文档的items字段中的元素数：

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

reduce功能要求

reduce function 具有以下原型：

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

reduce function 表现出以下行为：

• reduce function 不应该访问数据库，甚至不应该执行读操作。
• reduce function 不应影响外部系统。
• MongoDB 不会为只有一个 value 的 key 调用reduce function。 values参数是一个 array，其元素是value objects，它们被“映射”到key。
• MongoDB 可以为同一个 key 多次调用reduce function。在这种情况下，该 key 的reduce function 的前一个输出将成为该 key 的下一个reduce function 调用的输入值之一。
• reduce function 可以访问scope参数中定义的变量。
• reduce的输入不得大于 MongoDB 的最大 BSON 文件大小的一半。返回大型文档然后在后续的reduce步骤中将其连接在一起时，可能会违反此要求。
• 从版本4.2.1开始，MongoDB在该功能的作用域（即BSON类型15）中弃用JavaScript reduce。要确定变量的范围，请改用scope 参数。

因为可以为同一个 key 多次调用reduce function，所以以下 properties 需要 true：

• return object 的类型必须与map function 发出的value的类型相同。

• reduce function 必须是关联的。以下语句必须是 true：

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

• reduce function 必须是幂等的。确保以下语句是 true：

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

• reduce function 应该是可交换的：也就是说，valuesArray中元素的 order 不应该影响reduce function 的输出，因此以下语句是 true：

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

  选项

您可以为out参数指定以下选项：

输出到集合

此选项输出到新集合，并且在副本集的辅助成员上不可用。

out: <collectionName>

输出到带有 Action 的 Collection

注意

从4.2版开始，MongoDB弃用：

• 地图-reduce选项来创建一个新的分片集合以及使用的分片供选择的map-reduce。要输出到分片集合，请首先创建分片集合。MongoDB 4.2还不建议替换现有分片集合。
• nonAtomic：false选项的显式规范。

此选项仅在将已存在的集合传递给out时可用。它不适用于副本集 的辅助成员。

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

当您输出带有操作的集合时，out具有以下参数：

• <action>：指定以下操作之一：

  • replace

    如果具有<collectionName>的集合存在，则替换<collectionName>的内容。

  • merge

    如果输出集合已存在，则将新结果与现有结果合并。如果现有文档与新结果具有相同的 key，则覆盖该现有文档。

  • reduce

    如果输出集合已存在，则将新结果与现有结果合并。如果现有文档与新结果具有相同的 key，则将reduce function 应用于新文档和现有文档，并使用结果覆盖现有文档。

• db :

  可选的。您希望 map-reduce 操作写入其输出的数据库的 name。默认情况下，这将是与输入集合相同的数据库。

• sharded :

  可选的。如果true并且您已在输出数据库上启用了分片，则 map-reduce 操作将使用_id字段分割输出集合作为分片 key。

  如果true和collectionName是现有的未整数集合，map-reduce 将失败。

• nonAtomic :

  注意

  开始在MongoDB中4.2，明确设置nonAtomic到false已被弃用。

  可选的。将输出操作指定为 non-atomic。这仅对merge和reduce输出模式应用，这可能需要几分钟才能执行。

  默认情况下nonAtomic是false，map-reduce 操作在 post-processing 期间锁定数据库。

  如果nonAtomic是true，则 post-processing step 会阻止 MongoDB 锁定数据库：在此 time 期间，其他 clients 将能够读取输出集合的中间状态。

  输出内联

在 memory 中执行 map-reduce 操作并 return 结果。此选项是副本集的辅助成员上out的唯一可用选项。

out: { inline: 1 }

结果必须符合BSON 文档的最大大小。

finalize功能要求

finalize function 具有以下原型：

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

finalize function 接收value 作为其 arguments 和reduce function 的reducedValue。意识到：

• finalize function 不应出于任何原因访问数据库。
• finalize function 应该是纯的，或者在 function 之外没有影响(即：side effects.)
• finalize function 可以访问scope参数中定义的变量。

• 从版本4.2.1开始，MongoDB在该功能的作用域（即BSON类型15）中弃用JavaScript finalize。要确定变量的范围，请改用scope 参数。

  Map-Reduce 例子

聚合管道作为替代

聚合管道比map-reduce提供更好的性能和更一致的接口。

各种map-reduce表达式可以使用被重写聚合管道运算符，诸如$group， $merge等

下面的示例包括聚合管道备选方案。

orders使用以下文档创建样本集合：

db.orders.insertMany([
   { _id: 1, cust_id: "Ant O. Knee", ord_date: new Date("2020-03-01"), price: 25, items: [ { sku: "oranges", qty: 5, price: 2.5 }, { sku: "apples", qty: 5, price: 2.5 } ], status: "A" },
   { _id: 2, cust_id: "Ant O. Knee", ord_date: new Date("2020-03-08"), price: 70, items: [ { sku: "oranges", qty: 8, price: 2.5 }, { sku: "chocolates", qty: 5, price: 10 } ], status: "A" },
   { _id: 3, cust_id: "Busby Bee", ord_date: new Date("2020-03-08"), price: 50, items: [ { sku: "oranges", qty: 10, price: 2.5 }, { sku: "pears", qty: 10, price: 2.5 } ], status: "A" },
   { _id: 4, cust_id: "Busby Bee", ord_date: new Date("2020-03-18"), price: 25, items: [ { sku: "oranges", qty: 10, price: 2.5 } ], status: "A" },
   { _id: 5, cust_id: "Busby Bee", ord_date: new Date("2020-03-19"), price: 50, items: [ { sku: "chocolates", qty: 5, price: 10 } ], status: "A"},
   { _id: 6, cust_id: "Cam Elot", ord_date: new Date("2020-03-19"), price: 35, items: [ { sku: "carrots", qty: 10, price: 1.0 }, { sku: "apples", qty: 10, price: 2.5 } ], status: "A" },
   { _id: 7, cust_id: "Cam Elot", ord_date: new Date("2020-03-20"), price: 25, items: [ { sku: "oranges", qty: 10, price: 2.5 } ], status: "A" },
   { _id: 8, cust_id: "Don Quis", ord_date: new Date("2020-03-20"), price: 75, items: [ { sku: "chocolates", qty: 5, price: 10 }, { sku: "apples", qty: 10, price: 2.5 } ], status: "A" },
   { _id: 9, cust_id: "Don Quis", ord_date: new Date("2020-03-20"), price: 55, items: [ { sku: "carrots", qty: 5, price: 1.0 }, { sku: "apples", qty: 10, price: 2.5 }, { sku: "oranges", qty: 10, price: 2.5 } ], status: "A" },
   { _id: 10, cust_id: "Don Quis", ord_date: new Date("2020-03-23"), price: 25, items: [ { sku: "oranges", qty: 10, price: 2.5 } ], status: "A" }
])

返回每位客户的总价格

通过cust_id对orders集合执行 map-reduce 操作到 group，并为每个cust_id计算price的总和：

1. 定义map功能来处理每个输入文档：

2. 在 function 中，this指的是 map-reduce 操作正在处理的文档。

3. function maps 为每个文档的cust_id并发出cust_id和price键值对。

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

4. 使用两个参数 keyCustId和valuesPrices定义相应的 reduce function：

5. valuesPrices是一个数组，其元素是 map function 发出的price值，并按keyCustId分组。

6. function 将valuesPrice array 缩减为其元素的总和。

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

7. 使用mapFunction1 map function 和reduceFunction1 reduce function 对orders集合中的所有文档执行 map-reduce。

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

   此操作将结果输出到名为map_reduce_example的集合。如果map_reduce_example集合已存在，则操作将使用此 map-reduce 操作的结果替换内容。

8. 查询map_reduce_example集合以验证结果：

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

   该操作返回以下文档：

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

   聚合替代

使用可用的聚合管道运算符，您可以重写map-reduce操作，而无需定义自定义函数：

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

1. $group由平台组cust_id并计算value字段（参见$sum）。该 value字段包含price每个的总计cust_id。

   该阶段将以下文档输出到下一阶段：

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

2. 然后，$out将输出写入collection agg_alternative_1。或者，您可以使用 $merge代替$out。

3. 查询agg_alternative_1集合以验证结果：

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

   该操作返回以下文档：

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

   使用 Item 的平均数量计算 Order 和总数量

在此事例中，您将对orders集合执行 map-reduce 操作，以处理ord_date value 大于01/01/2012的所有文档。操作按item.sku字段分组，并计算每个sku的订单数量和订购总数量。然后，该操作将为每个值计算每个订单的平均数量，并将结果合并到输出集合中。合并结果时，如果现有文档的密钥与新结果相同，则该操作将覆盖现有文档。如果不存在具有相同密钥的文档，则该操作将插入该文档。

1. 定义map功能来处理每个输入文档：

2. 在 function 中，this指的是 map-reduce 操作正在处理的文档。

3. 对于每个 item，函数将sku与一个新的 object value相关联，该对象 value包含订单的count和_ite用于 order 并发出sku和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);
       }
   };
   

4. 使用两个 arguments keySKU和countObjVals定义相应的 reduce function：

5. countObjVals是一个 array，其元素是映射到 map function 传递给 reducer function 的分组keySKU值的 objects。

6. function 将countObjVals array 缩减为包含count和qty字段的单个 object reducedValue。

7. 在reducedVal中，count字段包含来自各个 array 元素的count字段的总和，qty字段包含来自各个 array 元素的qty字段的总和。

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

8. 使用两个 arguments key和reducedVal定义 finalize function。 function 修改reducedVal object 以添加名为avg的计算字段并返回修改后的 object：

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

9. 使用mapFunction2，reduceFunction2和finalizeFunction2函数对orders集合执行 map-reduce 操作。

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

   此操作使用query字段仅选择ord_date大于new Date(01/01/2012)的文档。然后它将结果输出到集合map_reduce_example。如果map_reduce_example集合已存在，则操作将现有内容与此 map-reduce 操作的结果合并。也就是说，如果现有文档具有与新结果相同的密钥，则该操作将覆盖现有文档。如果不存在具有相同密钥的文档，则该操作将插入该文档。

10. 查询map_reduce_example2集合以验证结果：

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

    该操作返回以下文档：

    { "_id" : "apples", "value" : { "count" : 3, "qty" : 30, "avg" : 10 } }
    { "_id" : "carrots", "value" : { "count" : 2, "qty" : 15, "avg" : 7.5 } }
    { "_id" : "chocolates", "value" : { "count" : 3, "qty" : 15, "avg" : 5 } }
    { "_id" : "oranges", "value" : { "count" : 6, "qty" : 58, "avg" : 9.666666666666666 } }
    { "_id" : "pears", "value" : { "count" : 1, "qty" : 10, "avg" : 10 } }
    

    聚合替代

使用可用的聚合管道运算符，您可以重写map-reduce操作，而无需定义自定义函数：

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" } }
] )

1. 该$match阶段仅选择ord_date大于或等于的那些文档。new Date("2020-03-01")

2. 该$unwinds阶段按items数组字段细分文档，以输出每个数组元素的文档。例如：

   { "_id" : 1, "cust_id" : "Ant O. Knee", "ord_date" : ISODate("2020-03-01T00:00:00Z"), "price" : 25, "items" : { "sku" : "oranges", "qty" : 5, "price" : 2.5 }, "status" : "A" }
   { "_id" : 1, "cust_id" : "Ant O. Knee", "ord_date" : ISODate("2020-03-01T00:00:00Z"), "price" : 25, "items" : { "sku" : "apples", "qty" : 5, "price" : 2.5 }, "status" : "A" }
   { "_id" : 2, "cust_id" : "Ant O. Knee", "ord_date" : ISODate("2020-03-08T00:00:00Z"), "price" : 70, "items" : { "sku" : "oranges", "qty" : 8, "price" : 2.5 }, "status" : "A" }
   { "_id" : 2, "cust_id" : "Ant O. Knee", "ord_date" : ISODate("2020-03-08T00:00:00Z"), "price" : 70, "items" : { "sku" : "chocolates", "qty" : 5, "price" : 10 }, "status" : "A" }
   { "_id" : 3, "cust_id" : "Busby Bee", "ord_date" : ISODate("2020-03-08T00:00:00Z"), "price" : 50, "items" : { "sku" : "oranges", "qty" : 10, "price" : 2.5 }, "status" : "A" }
   { "_id" : 3, "cust_id" : "Busby Bee", "ord_date" : ISODate("2020-03-08T00:00:00Z"), "price" : 50, "items" : { "sku" : "pears", "qty" : 10, "price" : 2.5 }, "status" : "A" }
   { "_id" : 4, "cust_id" : "Busby Bee", "ord_date" : ISODate("2020-03-18T00:00:00Z"), "price" : 25, "items" : { "sku" : "oranges", "qty" : 10, "price" : 2.5 }, "status" : "A" }
   { "_id" : 5, "cust_id" : "Busby Bee", "ord_date" : ISODate("2020-03-19T00:00:00Z"), "price" : 50, "items" : { "sku" : "chocolates", "qty" : 5, "price" : 10 }, "status" : "A" }
   ...
   

3. $group由平台组items.sku，计算每个SKU：

   • qty字段。该qty字段包含qty每个订单的总数items.sku（请参阅参考资料$sum）。

   • orders_ids阵列。该orders_ids字段包含不同顺序的阵列_id的对items.sku（参见 $addToSet）。

   { "_id" : "chocolates", "qty" : 15, "orders_ids" : [ 2, 5, 8 ] }
   { "_id" : "oranges", "qty" : 63, "orders_ids" : [ 4, 7, 3, 2, 9, 1, 10 ] }
   { "_id" : "carrots", "qty" : 15, "orders_ids" : [ 6, 9 ] }
   { "_id" : "apples", "qty" : 35, "orders_ids" : [ 9, 8, 1, 6 ] }
   { "_id" : "pears", "qty" : 10, "orders_ids" : [ 3 ] }
   

4. $project阶段调整输出文档的形状以反映map-reduce的输出，该输出具有两个字段_id和 value。该$projectsets：

   • value.count的尺寸在orders_ids数组中。（请参阅$size。）
   • value.qty在qty输入文档的字段。
   • value.avg每订购数量的平均数目。（请参阅$divide和$size。）

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

5. 最后，$merge将输出写入collection agg_alternative_3。如果现有文档的密钥_id与新结果相同，则该操作将覆盖现有文档。如果不存在具有相同密钥的文档，则该操作将插入该文档。

6. 查询agg_alternative_3集合以验证结果：

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

   该操作返回以下文档：

   { "_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.collection.mapReduce()方法的输出与MapReduce命令的输出相同。有关db.collection.mapReduce()输出的信息，请参阅MapReduce命令的产量部分。

限制

MongoDB驱动程序会自动将afterClusterTime设置为与因果一致的会话相关联的操作。从MongoDB 4.2开始， db.collection.mapReduce()不再支持 afterClusterTime。因此， db.collection.mapReduce()不能与因果一致的会话相关联 。

附加信息

• 对 Map Function 进行故障排除

• 排除 Reduce Function 问题

• MapReduce命令

• 聚合

• Map-Reduce

• 执行增量 Map-Reduce

译者：李冠飞

校对：

参见

原文 - db.collection.mapReduce()