db.colección.mapReduce() (método mongosh)

Salida a una colección

Esta opción genera la salida en una nueva colección y no está disponible en los miembros secundarios de sets de réplicas.

out: <collectionName>

Salida a una colección con una acción

Esta opción solo está disponible al transferir una colección ya existente a out. No está disponible en miembros secundarios de conjuntos de réplicas.

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

Cuando se envía una salida a una colección con una acción, el out tiene los siguientes parámetros:

• <action>Especifique una de las siguientes acciones:

  • replace

    Reemplace el contenido de la <collectionName> si la colección con la <collectionName> existe.

  • merge

    Combina el nuevo resultado con el resultado existente si la colección de salida ya existe. Si un documento existente tiene la misma clave que el nuevo resultado, sobrescribe ese documento existente.

  • reduce

    Fusiona el nuevo resultado con el resultado existente si la colección de salida ya existe. Si un documento existente tiene la misma clave que el nuevo resultado, aplica la función reduce tanto a los documentos nuevos como a los existentes y sobrescribe el documento existente con el resultado.

• db:

  opcional. El nombre de la base de datos en la que deseas que la operación de map-reduce guarde su resultado. Por defecto, esta será la misma base de datos que la colección de entrada.

Salida Inline

Realice la operación de map-reduce en la memoria y devuelva el resultado. Esta opción es la única opción disponible para out en los miembros secundarios de los set de réplicas.

out: { inline: 1 }

El resultado debe ajustarse al tamaño máximo de un documento BSON.

Devolver el precio total por cliente

Realice la operación map-reduce en la colección orders para agrupar por cust_id y calcular la suma de price para cada cust_id:

1. Defina la función de mapeo para procesar cada documento de entrada:

   • En la función, this se refiere al documento que la operación de map-reduce está procesando.

   • La función asigna price a cust_id para cada documento y emite cust_id y price.

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

2. Define la función de reducción correspondiente con dos argumentos keyCustId y valuesPrices:

   • El valuesPrices es un arreglo cuyos elementos son los valores price emitidos por la función map y agrupados por keyCustId.

   • La función reduce la matriz valuesPrice a la suma de sus elementos.

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

3. Realiza map-reduce en todos los documentos de la colección orders utilizando la función de mapeo mapFunction1 y la función de reducción reduceFunction1:

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

   Esta operación envía los resultados a una colección llamada map_reduce_example. Si la colección map_reduce_example ya existe, la operación reemplazará el contenido con los resultados de esta operación de map-reduce.

4. Query la colección map_reduce_example para verificar los resultados:

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

   La operación devuelve estos 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" }
])

Calcular el pedido y la cantidad total con la cantidad promedio por artículo

En el siguiente ejemplo, se verá una operación de map-reduce en la colección orders para todos los documentos que tengan un valor de ord_date mayor o igual a 2020-03-01.

La operación en el ejemplo:

1. Agrupa por el campo item.sku y calcula el número de órdenes y la cantidad total ordenada para cada sku.

2. Calcula la cantidad promedio por pedido para cada valor de sku y fusiona los resultados en la colección de salida.

Al fusionar resultados, si un documento existente tiene la misma clave que el nuevo resultado, la operación lo sobrescribe. Si no existe ningún documento con la misma clave, la operación lo inserta.

Ejemplo de pasos:

1. Defina la función de mapeo para procesar cada documento de entrada:

   • En la función, this se refiere al documento que la operación de map-reduce está procesando.

   • Para cada elemento, la función asocia el sku con un nuevo objeto value que contiene el count de 1 y el elemento qty para la orden y emite el sku (almacenado en el key) y el 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 la función de reducción correspondiente con dos argumentos keySKU y countObjVals:

   • countObjVals es un arreglo cuyos elementos son los objetos asignados a los valores agrupados keySKU pasados por la función map a la función reducer.

   • La función reduce el arreglo countObjVals a un solo objeto reducedValue que contiene los campos count y qty.

   • En reducedVal, el campo count contiene la suma de los count campos de los elementos individuales de la matriz, y el campo qty contiene la suma de los qty campos de los elementos individuales de la matriz.

   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 una función de finalización con dos argumentos key y reducedVal. La función modifica el objeto reducedVal para añadir un campo calculado llamado avg y devuelve el objeto modificado:

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

4. Realice la operación map-reduce en la colección orders utilizando las funciones mapFunction2, reduceFunction2 y finalizeFunction2:

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

   Esta operación utiliza el campo query para seleccionar solo los documentos con un valor ord_date mayor o igual a new Date("2020-03-01"). Luego, envía los resultados a una colección map_reduce_example2.

   Si la colección map_reduce_example2 ya existe, la operación fusionará el contenido existente con los resultados de esta operación de map-reduce. Es decir, si un documento existente tiene la misma clave que el nuevo resultado, la operación sobrescribirá el documento existente. Si no existe un documento con la misma clave, la operación inserta el documento.

5. Query la colección map_reduce_example2 para verificar los resultados:

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

   La operación devuelve estos 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" } }
] )