$minN (acumulador de agregación)

Valores nulos y faltantes

• $minN filtra valores nulos y faltantes.

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 gameId por. Este ejemplo solo tiene un,.gameIdG1

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

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

• Dado que solo hay 3 documentos con scores, minN devuelve el mínimo de 3 score campos aunque n = 4.

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

Comparación de $minN los $bottomN acumuladoresy

$minN $bottomN Los acumuladores y pueden lograr resultados similares.

En general:

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

• Si garantizar un orden de clasificación particular es un $bottomN requisito, utilice.

• Utilice si no desea ordenar los valores de $bottomN salida.

Compatibilidad con funciones de ventana y expresiones de agregación

Puedes utilizar como $minN acumulador.

$minN se admite como expresión de agregación.

$minN se admite window operator como.

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

Puedes utilizar el acumulador $minN para encontrar las tres puntuaciones mínimas en un solo juego.

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

El ejemplo de canalización:

• Utiliza para filtrar los resultados según un $match único.gameId En esteG1 caso,.

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

• Especifica los campos que se ingresan 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 las puntuaciones mínimas n en cada juego.

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

El ejemplo de canalización:

• Utiliza $group para agrupar los resultados por gameId.

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

• Especifica los campos que se ingresan 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 n de según la clave de grupo para $group

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

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

El ejemplo de canalización:

• Utiliza $group para agrupar los resultados por gameId.

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

• Si 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' ] ]
   }
]