$maxN (acumulador de agregación)

Valores nulos y faltantes

• $maxN filtra los valores nulos y ausentes.

Considera la siguiente agregación que devuelve los n documentos máximos 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",
         maximumThreeScores:
            {
               $maxN:
                  {
                     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. Estos valores se consideran ambos nulos.

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

• Dado que solo hay 3 documentos con scores, maxN devuelve un máximo de 3 campos score aunque n = 4.

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

Comparación de los acumuladores $maxN y $topN

Tanto los acumuladores $maxN como los $topN pueden lograr resultados similares.

En general:

• $maxN tiene la ventaja de encontrar valores máximos en un orden de clasificación no particular. Si desea conocer los valores máximos para n documentos, utilice $maxN.

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

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

Compatibilidad con funciones de ventana y expresiones de agregación

Puede usar $maxN como un acumulador.

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

$maxN es compatible como un window operator.

Consideraciones sobre el límite de memoria

Las pipelines de agregación que llaman a $maxN 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 Scores máxima en una sola partida

Puedes usar el acumulador $maxN para encontrar las tres puntuaciones máximas en una sola partida.

db.gamescores.aggregate( [
   {
      $match : { gameId : "G1" }
   },
   {
      $group:
         {
            _id: "$gameId",
            maxThreeScores:
               {
                  $maxN:
                  {
                     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 $maxN con input : ["$score","$playerId"].

• Utiliza $maxN para devolver los tres elementos de puntuación máximos para el juego G1 con n : 3.

La operación devuelve los siguientes resultados:

[
   {
      _id: 'G1',
      maxThreeScores: [ [ 99, 'PlayerC' ], [ 33, 'PlayerB' ], [ 31, 'PlayerA' ] ]
   }
]

Encontrar las tres puntuaciones máximas en varios juegos

Puede usar el acumulador $maxN para encontrar los puntajes máximos de n en cada juego.

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

La pipeline de ejemplo:

• Utiliza $group para agrupar los resultados por gameId.

• Utiliza $maxN para devolver los tres elementos de puntuación más altos para cada juego con n: 3.

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

La operación devuelve los siguientes resultados:

[
   {
      _id: 'G1',
      maxScores: [ [ 99, 'PlayerC' ], [ 33, 'PlayerB' ], [ 31, 'PlayerA' ] ]
   },
   {
      _id: 'G2',
      maxScores: [ [ 80, 'PlayerD' ], [ 66, 'PlayerC' ], [ 14, '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:
            {
               $maxN:
                  {
                     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 $maxN 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: [ [ 80, 'PlayerD' ] ] },
   {
      _id: { gameId: 'G1' },
      gamescores: [ [ 99, 'PlayerC' ], [ 33, 'PlayerB' ], [ 31, 'PlayerA' ] ]
   }
]