$minN (acumulador de agregación)

Valores nulos y faltantes

• $minN filtra los valores nulos y ausentes.

Considere la siguiente agregación que devuelve los n documentos mínimos de un grupo:

db.aggregate( [
   {
      $documents: [
         { playerId: "PlayerA", gameId: "G1", score: 1 },
         { playerId: "PlayerB", gameId: "G1", score: 2 },
         { playerId: "PlayerC", gameId: "G1", score: 3 },
         { playerId: "PlayerD", gameId: "G1" },
         { playerId: "PlayerE", gameId: "G1", score: null }
      ]
   },
   {
      $group:
      {
         _id: "$gameId",
         minimumThreeScores:
            {
               $minN:
                  {
                     input: "$score",
                     n: 4
                  }
            }
      }
   }
] )

En este ejemplo:

• $documents crea los documentos literales que contienen las puntuaciones de los jugadores.

• $group agrupa los documentos por gameId. Este ejemplo tiene solo un gameId, G1.

• PlayerD tiene una puntuación faltante y PlayerE tiene un score nulo. Ambos valores se ignoran.

• El campo minimumThreeScores se especifica como $minN con input : "$score" y se devuelve como un arreglo.

• Dado que solo hay 3 documentos con scores minN devuelve los 3 campos score mínimos aunque n = 4.

[
   {
   _id: 'G1',
   minimumThreeScores: [ 1, 2, 3 ]
   }
]

Comparación de los acumuladores $minN y $bottomN

Tanto los acumuladores $minN como los $bottomN pueden lograr resultados similares.

En general:

• $minN tiene la ventaja de encontrar valores mínimos sin un orden específico de clasificación. Si desea conocer los valores mínimos de n documentos, utilice $minN.

• Si garantizar un orden de clasificación específico es un requisito, utiliza $bottomN.

• Utiliza $bottomN si no tienes la intención de ordenar los valores de salida.

Compatibilidad con funciones de ventana y expresiones de agregación

Puede usar $minN como un acumulador.

$minN está soportado como una expresión de agregación.

$minN es compatible como un window operator.

Consideraciones sobre el límite de memoria

Las pipelines de agregación que llaman a $minN están sujetas al límite de 100 MB. Si se supera este límite para un grupo individual, la agregación falla con un error.

Encuentra el mínimo de tres Scores para un solo juego

Puede usar el acumulador $minN para encontrar las tres puntuaciones más bajas en un solo juego.

db.gamescores.aggregate( [
   {
      $match : { gameId : "G1" }
   },
   {
      $group:
         {
            _id: "$gameId",
            minScores:
               {
                  $minN:
                  {
                     input: ["$score","$playerId"],
                     n:3
                  }
               }
         }
   }
] )

La pipeline de ejemplo:

• Utiliza $match para filtrar los resultados en un solo gameId. En este caso, G1.

• Usa $group para agrupar los resultados por gameId. En este caso, G1.

• Especifica los campos que son datos para $minN con input : ["$score","$playerId"].

• Utiliza $minN para devolver los primeros tres elementos de puntuación para el juego G1 con n : 3.

La operación devuelve los siguientes resultados:

[
   {
      _id: 'G1',
      minScores: [ [ 1, 'PlayerD' ], [ 31, 'PlayerA' ], [ 33, 'PlayerB' ] ]
   }
]

Encontrar los tres documentos mínimos entre varios juegos

Puedes utilizar el acumulador $minN para encontrar los n puntajes mínimos en cada juego.

db.gamescores.aggregate( [
   {
      $group:
      {
         _id: "$gameId",
         minScores:
            {
               $minN:
                  {
                     input: ["$score","$playerId"],
                     n: 3
                  }
            }
      }
   }
] )

La pipeline de ejemplo:

• Utiliza $group para agrupar los resultados por gameId.

• Utiliza $minN para devolver los tres elementos de puntuación mínimos de cada juego con n: 3.

• Especifica los campos que son datos para $minN con input: ["$score","$playerId"].

La operación devuelve los siguientes resultados:

[
   {
      _id: 'G2',
      minScores: [ [ 10, 'PlayerA' ], [ 14, 'PlayerB' ], [ 66, 'PlayerC' ] ]
   },
   {
      _id: 'G1',
      minScores: [ [ 1, 'PlayerD' ], [ 31, 'PlayerA' ], [ 33, 'PlayerB' ] ]
   }
]

Cálculo de n en función de la clave de grupo para $group

También puede asignar dinámicamente el valor de n. En este ejemplo, se utiliza la expresión $cond en el campo gameId.

db.gamescores.aggregate([
   {
      $group:
      {
         _id: {"gameId": "$gameId"},
         gamescores:
            {
               $minN:
                  {
                     input: ["$score","$playerId"],
                     n: { $cond: { if: {$eq: ["$gameId","G2"] }, then: 1, else: 3 } }
                  }
            }
      }
   }
] )

La pipeline de ejemplo:

• Utiliza $group para agrupar los resultados por gameId.

• Especifica los campos que se ingresan para $minN con input : ["$score","$playerId"].

• Si el gameId es G2 entonces n es 1, de lo contrario n es 3.

La operación devuelve los siguientes resultados:

[
   { _id: { gameId: 'G2' }, gamescores: [ [ 10, 'PlayerA' ] ] },
   {
      _id: { gameId: 'G1' },
      gamescores: [ [ 1, 'PlayerD' ], [ 31, 'PlayerA' ], [ 33, 'PlayerB' ] ]
   }
]