$bottomN (operador acumulador)

Valores nulos y faltantes

• $bottomN no filtra valores nulos.

• $bottomN Convierte los valores faltantes en nulos, que se conservan en la salida.

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

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

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

• Debido a sortBy: { "score" : -1 }, los valores nulos se ordenan al final de la matriz playerId devuelta.

[
   {
      _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 la ordenación. Por ejemplo, considere una colección cuyos valores consisten en cadenas y números.

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

• En una ordenación descendente, los valores de cadena 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 una partitura de cuerda vacía.

Debido a que la clasificación se realiza en orden descendente { "score" : -1 }, los valores literales de cadena se ordenan antes que 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 se admite como expresión de agregación.

$bottomN se admite window operator como.

Consideraciones sobre el límite de memoria

Los grupos dentro del $bottomN flujo de agregación están sujetos al 100 límite de 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 ordenar por { "score": -1 } para ordenar los resultados en orden descendente.

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

• Utiliza $bottomN para devolver los tres documentos inferiores con el score más bajo para 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 varios juegos

Puedes utilizar el acumulador $bottomN para encontrar 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 generan desde $bottomN con output : ["$playerId", "$score"].

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

• Utiliza $bottomN para devolver los tres últimos documentos con el score más bajo 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 generan desde $bottomN con output : "$score".

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

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