/ /

$topN (operador de acumulación)

Definición

$topN

Devuelve una agregación de los n elementos principales dentro de un grupo, de acuerdo con el orden de clasificación especificado. Si el grupo contiene menos de n elementos, $topN devuelve todos los elementos del grupo.

Nota

Otros usos de $topN

Esta página describe $topN cuando se utiliza como acumulador. Los acumuladores devuelven un valor agregado a partir de un grupo de documentos de entrada.

También puedes usar $topN en estos otros contextos:

$topN (window function), que devuelve los elementos n superiores de los documentos en una ventana particular según el orden de clasificación especificado.
$topN (expression), que devuelve los n elementos superiores de una matriz.

Sintaxis

{
   $topN:
      {
         n: <expression>,
         sortBy: { <field1>: <sort order>, <field2>: <sort order> ... },
         output: <expression>
      }
}

Campo	Tipo	Descripción
`n`	expresión	Determina el número máximo de resultados devueltos por grupo. `n` debe evaluarse como un número entero positivo.
`sortBy`	Documento	Especifica el orden de los resultados, con una sintaxis similar a `$sort`. No afecta al orden de los documentos en la salida del pipeline.
`output`	expresión	Especifica la salida para cada elemento del grupo. Puede ser cualquier expresión.

Comportamiento

Valores nulos y faltantes

$topN no filtra los valores nulos.
$topN 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:
            {
               $topN:
                  {
                     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 principio del arreglo de playerId devueltos.

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

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: {
               $topN:
               {
                  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 ] ]
   }
]

Ejemplos

Los ejemplos de esta página utilizan datos del conjunto de datos sample_mflix. Para obtener más información sobre cómo cargar este conjunto de datos en su implementación autogestionada de MongoDB, consulte Cargar el conjunto de datos de ejemplo. Si realizó alguna modificación en las bases de datos de ejemplo, es posible que deba eliminarlas y volver a crearlas para ejecutar los ejemplos de esta página.

Encuentra las tres películas mejor valoradas de un mismo género.

Puedes usar el acumulador $topN para encontrar las tres películas mejor valoradas del género Short.

db.movies.aggregate( [
   {
      $match: {
         genres: "Short",
         "imdb.rating": { $gt: 0 }
      }
   },
   {
      $group: {
         _id: "Short",
         topRatedMovies: {
            $topN: {
               output: [ "$title", "$imdb.rating" ],
               sortBy: { "imdb.rating": -1, title: 1 },
               n: 3
            }
         }
      }
   }
] )

[
  {
    _id: 'Short',
    topRatedMovies: [
      [ 'Rabbit and Deer', 8.7 ],
      [ 'Assume the Position with Mr. Wuhl', 8.6 ],
      [ 'Hole', 8.6 ]
    ]
  }
]

La pipeline de ejemplo:

Utiliza $match para restringir la entrada a las películas Short que incluyen un valor imdb.rating.
Utiliza $group para colocar las películas coincidentes en un único grupo Short.
Utiliza sortBy: { "imdb.rating": -1, title: 1 } para clasificar las películas por calificación y title como criterio de desempate.
Especifica los campos devueltos por $topN con output: [ "$title", "$imdb.rating" ].
Utiliza $topN para devolver las tres películas que mejor coinciden con n: 3.

Encuentra las películas mejor valoradas de cada género.

Puedes usar el acumulador $topN para encontrar las películas mejor valoradas de cada género.

db.movies.aggregate( [
   {
      $unwind: "$genres"
   },
   {
      $match: {
         "imdb.rating": { $gt: 0 }
      }
   },
   {
      $group: {
         _id: "$genres",
         topRatedMovies: {
            $topN: {
               output: [ "$title", "$imdb.rating" ],
               sortBy: { "imdb.rating": -1, title: 1 },
               n: 3
            }
         }
      }
   },
   {
      $sort: { _id: 1 }
   },
   {
      $limit: 5
   }
] )

[
  {
    _id: 'Action',
    topRatedMovies: [
      [ 'Band of Brothers', 9.6 ],
      [ 'The Real Miyagi', 9.3 ],
      [ 'The Dark Knight', 9 ]
    ]
  },
  {
    _id: 'Adventure',
    topRatedMovies: [
      [ 'Over the Garden Wall', 9.2 ],
      [ 'Love is God', 8.9 ],
      [ 'The Lord of the Rings: The Return of the King', 8.9 ]
    ]
  },
  {
    _id: 'Animation',
    topRatedMovies: [
      [ 'Over the Garden Wall', 9.2 ],
      [ 'Death Note', 9 ],
      [ 'Rabbit and Deer', 8.7 ]
    ]
  },
  {
    _id: 'Biography',
    topRatedMovies: [
      [ 'A Brave Heart: The Lizzie Velasquez Story', 9.4 ],
      [ "Schindler's List", 8.9 ],
      [ 'Shining Night: A Portrait of Composer Morten Lauridsen', 8.8 ]
    ]
  },
  {
    _id: 'Comedy',
    topRatedMovies: [
      [ 'Over the Garden Wall', 9.2 ],
      [ 'Heart of a Dog', 9 ],
      [ 'The Chaos Class Failed the Class', 9 ]
    ]
  }
]

La pipeline de ejemplo:

Utiliza $unwind para expandir el array genres de cada película.
Utiliza $match para conservar solo los documentos que incluyen un valor imdb.rating.
Utiliza $group para agrupar los resultados por género.
Especifica los campos devueltos por $topN con output: [ "$title", "$imdb.rating" ].
Utiliza sortBy: { "imdb.rating": -1, title: 1 } para clasificar las películas por calificación y utiliza title como un criterio de desempate determinista.
Utiliza $topN para devolver las tres mejores películas de cada género con n: 3.
Utiliza $sort y $limit para mostrar los primeros cinco géneros alfabéticamente.

Establecer n dinámicamente en función de la clave de grupo.

Puedes asignar el valor de n dinámicamente. El siguiente ejemplo utiliza la expresión $cond para devolver diferentes cantidades de películas según su clasificación por edades.

db.movies.aggregate( [
   {
      $match: {
         rated: { $in: [ "G", "PG", "PG-13", "R" ] },
         "imdb.rating": { $gt: 0 }
      }
   },
   {
      $group: {
         _id: { rated: "$rated" },
         movies: {
            $topN: {
               output: { title: "$title", rating: "$imdb.rating" },
               n: {
                  $cond: {
                     if: { $eq: [ "$rated", "PG" ] },
                     then: 3,
                     else: 1
                  }
               },
               sortBy: { "imdb.rating": -1 }
            }
         }
      }
   },
   {
      $sort: { "_id.rated": 1 }
   }
] )

[
  {
    _id: { rated: 'G' },
    movies: [ { title: 'Modern Times', rating: 8.6 } ]
  },
  {
    _id: { rated: 'PG' },
    movies: [
      { title: 'Life', rating: 9.2 },
      {
        title: 'Star Wars: Episode V - The Empire Strikes Back',
        rating: 8.8
      },
      { title: 'Andaz Apna Apna', rating: 8.8 }
    ]
  },
  {
    _id: { rated: 'PG-13' },
    movies: [
      {
        title: 'A Brave Heart: The Lizzie Velasquez Story',
        rating: 9.4
      }
    ]
  },
  {
    _id: { rated: 'R' },
    movies: [ { title: 'The Shawshank Redemption', rating: 9.3 } ]
  }
]

La pipeline de ejemplo:

Utiliza $match para conservar solo las películas con clasificaciones de contenido G, PG, PG-13 o R que incluyan un valor imdb.rating.
Utiliza $group para agrupar los resultados por calificación de contenido con _id: { rated: "$rated" }.
Especifica los campos devueltos por $topN con output: { title: "$title", rating: "$imdb.rating" }.
Si la clasificación de contenido es PG, entonces n es 3. De lo contrario, n es 1.
Utiliza sortBy: { "imdb.rating": -1 } para encontrar las mejores n películas según la puntuación de IMDb.
Ordena los resultados por calificación de contenido en orden alfabético.

Obtén más información

Volver

$top

Update