$bottomN (operador de acumulación)

Valores nulos y faltantes

• $bottomN no filtra los valores nulos.

• $bottomN convierte los valores faltantes a nulos, que se conservan en el resultado.

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",
            playerId:
               {
                  $bottomN:
                     {
                        output: [ "$playerId", "$score" ],
                        sortBy: { "score": -1 },
                        n: 3
                     }
               }
      }
   }
] )

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.

• Los campos playerId y score se especifican como output : ["$playerId"," $score"] y se devuelven como valores de un arreglo.

• Debido al sortBy: { "score" : -1 }, los valores nulos se ordenan al final del arreglo playerId devuelto.

[
   {
      _id: "G1",
      playerId: [ [ "PlayerA", 1 ], [ "PlayerD", null ], [ "PlayerE", null ] ]
   }
]

Orden de clasificación del tipo de datos BSON

Al ordenar diferentes tipos, se utiliza el orden de los tipos de datos BSON para determinar el orden. Como ejemplo, consideremos una colección cuyos valores consisten en cadenas y números.

• En una ordenación ascendente, los valores de string se ordenan después de los valores numéricos.

• En una ordenación descendente, los valores de string se ordenan antes que los valores numéricos.

db.aggregate( [
   {
      $documents: [
         { playerId: "PlayerA", gameId: "G1", score: 1 },
         { playerId: "PlayerB", gameId: "G1", score: "2" },
         { playerId: "PlayerC", gameId: "G1", score: "" }
      ]
   },
   {
      $group:
         {
            _id: "$gameId",
            playerId: {
               $bottomN:
               {
                  output: ["$playerId","$score"],
                  sortBy: {"score": -1},
                  n: 3
               }
            }
         }
   }
] )

En este ejemplo:

• PlayerA tiene una puntuación entera.

• PlayerB tiene una puntuación de string "2".

• PlayerC tiene un puntaje de string vacía.

Debido a que el ordenamiento es descendente { "score" : -1 }, los valores de literales de string se ordenan antes de la puntuación numérica de PlayerA:

[
   {
      _id: "G1",
      playerId: [ [ "PlayerB", "2" ], [ "PlayerC", "" ], [ "PlayerA", 1 ] ]
   }
]

Compatibilidad con funciones de ventana y expresiones de agregación

$bottomN no es compatible como expresión de agregación.

$bottomN es compatible como un window operator.

Consideraciones sobre el límite de memoria

Los grupos dentro del pipeline de agregación $bottomN están sujetos al límite de 100 MB. Si se supera este límite para un grupo individual, la agregación falla con un error.

Encuentra los Tres más Bajos Scores

Puedes usar el acumulador $bottomN para encontrar a los jugadores con las puntuaciones más bajas en un solo juego.

db.gamescores.aggregate( [
   {
      $match : { gameId : "G1" }
   },
   {
      $group:
         {
            _id: "$gameId",
            playerId:
               {
                  $bottomN:
                  {
                     output: ["$playerId", "$score"],
                     sortBy: { "score": -1 },
                     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.

• Utiliza ordenación por { "score": -1 } para ordenar los resultados en orden descendente.

• Especifica los campos que se producen de $bottomN con output : ["$playerId"," $score"].

• Utiliza $bottomN para devolver los tres documentos con el score más bajo en el juego G1 con n : 3.

La operación devuelve los siguientes resultados:

[
   {
      _id: "G1",
      playerId: [ [ "PlayerB", 33 ], [ "PlayerA", 31 ], [ "PlayerD", 1 ] ]
   }
]

El equivalente en SQL para esta query es:

SELECT T3.GAMEID,T3.PLAYERID,T3.SCORE
FROM GAMESCORES AS GS
JOIN (SELECT TOP 3
         GAMEID,PLAYERID,SCORE
         FROM GAMESCORES
         WHERE GAMEID = "G1"
         ORDER BY SCORE) AS T3
            ON GS.GAMEID = T3.GAMEID
GROUP BY T3.GAMEID,T3.PLAYERID,T3.SCORE
   ORDER BY T3.SCORE DESC

Encontrar los tres documentos con la puntuación más baja en múltiples juegos

Puede usar el acumulador $bottomN para encontrar a los jugadores con la puntuación más baja en cada juego.

db.gamescores.aggregate( [
      {
         $group:
         { _id: "$gameId", playerId:
            {
               $bottomN:
                  {
                     output: [ "$playerId","$score" ],
                     sortBy: { "score": -1 },
                     n: 3
                  }
            }
         }
      }
] )

La pipeline de ejemplo:

• Utiliza $group para agrupar los resultados por gameId.

• Especifica los campos que se producen de $bottomN con output : ["$playerId", "$score"].

• Utiliza ordenación por { "score": -1 } para ordenar los resultados en orden descendente.

• Utiliza $bottomN para devolver los tres documentos más bajos con el menor score para cada juego con n: 3.

La operación devuelve los siguientes resultados:

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

El equivalente en SQL para esta query es:

SELECT PLAYERID,GAMEID,SCORE
FROM(
   SELECT ROW_NUMBER() OVER (PARTITION BY GAMEID ORDER BY SCORE DESC) AS GAMERANK,
   GAMEID,PLAYERID,SCORE
   FROM GAMESCORES
) AS T
WHERE GAMERANK >= 2
ORDER BY GAMEID

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:
            {
               $bottomN:
                  {
                     output: "$score",
                     n: { $cond: { if: {$eq: ["$gameId","G2"] }, then: 1, else: 3 } },
                     sortBy: { "score": -1 }
                  }
            }
      }
   }
] )

La pipeline de ejemplo:

• Utiliza $group para agrupar los resultados por gameId.

• Especifica los campos que se producen de $bottomN con output : "$score".

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

• Utiliza ordenación por { "score": -1 } para ordenar los resultados en orden descendente.

La operación devuelve los siguientes resultados:

[
   { _id: { gameId: "G2" }, gamescores: [ 10 ] },
   { _id: { gameId: "G1" }, gamescores: [ 33, 31, 1 ] }
]