$top (operador de acumulación)

Valores nulos y faltantes

Considera la siguiente agregación que devuelve el documento más alto de un grupo de puntuaciones:

• $top no filtra los valores nulos.

• $top convierte los valores faltantes en null.

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

[
  { _id: 'G1', playerId: [ 'PlayerD', null ] }
]

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.

• Especifica el orden de clasificación con sortBy: { "score": 1 }.

• PlayerD y PlayerE empataron por el primer elemento. PlayerD se devuelve como el principal score.

• Para tener un comportamiento de empate más determinista para múltiples valores nulos, añada más campos a sortBy.

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.

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 la ordenación es descendente { "score": -1 }, los valores de cadena se ordenan antes que la puntuación numérica de PlayerA. $top devuelve el primer elemento después de la ordenación, que es PlayerB:

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

[ { _id: 'G1', playerId: [ 'PlayerB', '2' ] } ]

Encuentra la mejor calificación en un género

Puedes usar el acumulador $top para encontrar la película mejor valorada en un género.

db.movies.aggregate( [
   {
      $match: {
         genres: "Comedy",
         "imdb.rating": { $gt: 0 }
      }
   },
   {
      $group:
         {
            _id: "Comedy",
            highestRatedMovie:
               {
                  $top:
                  {
                     output: [ "$title", "$imdb.rating" ],
                     sortBy: { "imdb.rating": -1 }
                  }
               }
         }
   }
] )

[
  { _id: 'Comedy', highestRatedMovie: [ 'Over the Garden Wall', 9.2 ] }
]

La pipeline de ejemplo:

• Utiliza $match para filtrar películas de comedia con una calificación positiva en IMDb.

• Utiliza $group para agrupar todas las películas de comedia bajo una única clave de grupo "Comedy".

• Especifica los campos que se muestran para $top con output : ["$title", "$imdb.rating"].

• Utiliza sortBy: { "imdb.rating": -1 } para clasificar las películas dentro del grupo por calificación de IMDb en orden descendente, lo que determina la película que devuelve $top.

Encuentra la mejor calificación entre múltiples calificaciones.

Puedes usar el acumulador $top para encontrar la película mejor valorada para cada categoría de calificación de películas.

db.movies.aggregate( [
   {
      $match: {
         rated: { $in: [ "G", "PG", "PG-13", "R" ] },
         "imdb.rating": { $gt: 0 }
      }
   },
   {
      $group:
      {
         _id: "$rated",
         highestRatedMovie:
            {
               $top:
                  {
                     output: [ "$title", "$imdb.rating" ],
                     sortBy: { "imdb.rating": -1 }
                  }
            }
      }
   },
   {
      $sort: { _id: 1 }
   }
] )

[
  { _id: 'G', highestRatedMovie: [ 'Modern Times', 8.6 ] },
  { _id: 'PG', highestRatedMovie: [ 'Life', 9.2 ] },
  {
    _id: 'PG-13',
    highestRatedMovie: [ 'A Brave Heart: The Lizzie Velasquez Story', 9.4 ]
  },
  { _id: 'R', highestRatedMovie: [ 'The Shawshank Redemption', 9.3 ] }
]

La pipeline de ejemplo:

• Utiliza $match para filtrar películas en las categorías G, PG, PG-13 y R con una calificación positiva de IMDb.

• Utiliza $group para agrupar los resultados por rated.

• Utiliza $top para devolver la película mejor valorada de cada categoría.

• Especifica los campos que se muestran para $top con output : ["$title", "$imdb.rating"].

• Utiliza sortBy: { "imdb.rating": -1 } para clasificar las películas dentro de cada grupo por calificación de IMDb en orden descendente, lo que determina la película que devuelve $top.

• Utiliza $sort para ordenar los resultados alfabéticamente por categoría de calificación.