$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 ] ]
   }
]

Ordenamiento de tipos 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 cadena "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 utilizar el acumulador $bottomN para encontrar los jugadores con la puntuación más baja en un solo juego.

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

• 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
                  }
            }
         }
      }
] )

El ejemplo de canalización:

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

El ejemplo de canalización:

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