db.collection.mapReduce() (método mongosh)

Saída para uma collection

Esta opção gera resultados para uma nova collection e não está disponível para membros secundários de conjuntos de réplicas.

out: <collectionName>

Saída para uma collection com uma ação

Esta opção só está disponível ao passar uma collection que já existe para out. Não está disponível para membros secundários de conjuntos de réplicas.

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

Quando você gera resultados para uma coleção com uma ação, o out tem os seguintes parâmetros:

• <action>: especifique uma das seguintes ações:

  • replace

    Substitua o conteúdo de <collectionName> se a collection com <collectionName> existir.

  • merge

    Mescle o novo resultado com o resultado existente se a collection de saída já existir. Se um documento existente tiver a mesma chave que o novo resultado, substitua esse documento existente.

  • reduce

    Mescle o novo resultado com o resultado existente se a collection de saída já existir. Se um documento existente tiver a mesma chave que o novo resultado, aplique a função reduce aos documentos novo e existente e substitua o documento existente pelo resultado.

• db:

  Opcional. O nome do banco de dados em que você deseja que a operação map-reduce escreva sua saída. Por padrão, este será o mesmo banco de dados que a collection de entrada.

Gerar saída in-line

Execute a operação map-reduce na memória e retorne o resultado. Esta opção é a única disponível para out em membros secundários de conjuntos de réplicas.

out: { inline: 1 }

O resultado deve caber no tamanho máximo de um documento BSON.

Retornar o preço total por cliente

Execute a operação map-reduce na collection orders para agrupar pelo cust_id e calcule a soma do price para cada cust_id:

1. Defina a função do mapa para processar cada documento de entrada:

   • Na função, o this refere-se ao documento que a operação de redução de mapa está processando.

   • A função mapeia o price para o cust_id para cada documento e emite o cust_id e price.

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

2. Defina a função de redução correspondente com dois argumentos keyCustId e valuesPrices:

   • O valuesPrices é uma array cujos elementos são os valores price emitidos pela função de mapa e agrupados por keyCustId.

   • A função reduz a array valuesPrice à soma de seus elementos.

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

3. Executar a redução de mapa em todos os documentos na coleção do orders utilizando a função de mapa do mapFunction1 e a função de redução do reduceFunction1 :

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

   Esta operação gera resultados para uma coleção denominada map_reduce_example. Se a coleção map_reduce_example já existir, a operação substituirá o conteúdo pelos resultados desta operação de redução de mapa.

4. Consulte a coleção map_reduce_example para verificar os resultados:

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

   A operação retorna estes documentos:

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

Calcule o pedido e a quantidade total com a quantidade média por item

No exemplo seguinte, você visualizará uma operação de map-reduce na collection orders para todos os documentos que têm um valor ord_date maior ou igual a 2020-03-01.

A operação no exemplo:

1. Agrupa pelo campo item.sku e calcula o número de pedidos e a quantidade total solicitada para cada sku.

2. Calcula a quantidade média por pedido para cada valor sku e mescla os resultados na coleta de saída.

Ao mesclar resultados, se um documento existente tiver a mesma chave que o novo resultado, a operação substituirá o documento existente. Se não houver nenhum documento existente com a mesma chave, a operação inserirá o documento.

Etapas de exemplo:

1. Defina a função do mapa para processar cada documento de entrada:

   • Na função, o this refere-se ao documento que a operação de redução de mapa está processando.

   • Para cada item, a função associa o sku a um novo objeto value que contém o count de 1 e o item qty para o pedido e emite o sku (armazenado no key) e o 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. Defina a função de redução correspondente com dois argumentos keySKU e countObjVals:

   • countObjVals é uma matriz cujos elementos são os objetos mapeados para os valores agrupados do keySKU passados pela função de mapa para a função redutor.

   • A função reduz a matriz countObjVals para um único objeto reducedValue que contém os campos count e qty.

   • Em reducedVal, o campo count contém a soma dos campos count dos elementos individuais da array e o campo qty contém a soma dos campos qty dos elementos individuais da array.

   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. Defina uma função de finalização com dois argumentos key e reducedVal. A função modifica o objeto reducedVal para adicionar um campo calculado denominado avg e retorna o objeto modificado:

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

4. Execute a operação de redução de mapa na coleção do orders utilizando as funções mapFunction2, reduceFunction2 e finalizeFunction2:

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

   Esta operação utiliza o campo query para selecionar apenas os documentos com ord_date maior ou igual a new Date("2020-03-01"). Em seguida, ele envia os resultados para uma coleção map_reduce_example2.

   Se a coleção map_reduce_example2 já existir, a operação fundirá o conteúdo existente com os resultados desta operação de redução de mapa. Ou seja, se um documento existente tiver a mesma chave que o novo resultado, a operação substituirá o documento existente. Se não houver nenhum documento existente com a mesma chave, a operação inserirá o documento.

5. Consulte a coleção map_reduce_example2 para verificar os resultados:

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

   A operação retorna estes documentos:

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