/ /

$bottomN (operador de acumulación)

Definición

$bottomN: Nuevo en la versión 5.2.
Devuelve una agregación de los n elementos inferiores dentro de un grupo, de acuerdo con el orden de clasificación especificado. Si el grupo contiene menos de n elementos, $bottomN devuelve todos los elementos del grupo.

Nota

Desambiguación

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

También puede utilizar $bottomN (window function), que devuelve los elementos n inferiores de los documentos en una ventana en particular según el orden de clasificación especificado.

Sintaxis

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

opciones

Campo	Necesidad	Descripción
`n`	Requerido	El número de elementos que `$bottomN` devuelve del grupo. Para ver un ejemplo de cómo establecer n dinámicamente, consulte Establecer n dinámicamente según la clave del grupo.
`output`	Requerido	Determina el resultado para cada elemento del grupo. Puede ser cualquier expresión.
`sortBy`	Requerido	Define el orden de clasificación de los elementos dentro de cada grupo, con una sintaxis similar a `$sort`. No afecta el orden de los documentos en la salida del pipeline.

Comportamiento

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

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 peor valoradas de un mismo género.

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

db.movies.aggregate( [
   {
      $match: {
         genres: "Short",
         "imdb.rating": { $exists: true }
      }
   },
   {
      $group: {
         _id: "Short",
         lowestRatedMovies: {
            $bottomN: {
               output: [ "$title", "$imdb.rating" ],
               sortBy: { "imdb.rating": -1, title: 1 },
               n: 3
            }
         }
      }
   }
] )

[
  {
    _id: 'Short',
    lowestRatedMovies: [
      [ 'Andrè and Wally B.', 5.4 ],
      [ 'The Education of Mohammad Hussein', 5.4 ],
      [ 'Enigma', 5.3 ]
    ]
  }
]

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 $bottomN con output: [ "$title", "$imdb.rating" ].
Utiliza $bottomN para devolver las tres películas que coinciden con n: 3.

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

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

db.movies.aggregate( [
   {
      $unwind: "$genres"
   },
   {
      $match: {
         "imdb.rating": { $exists: true }
      }
   },
   {
      $group: {
         _id: "$genres",
         lowestRatedMovie: {
            $bottomN: {
               output: [ "$title", "$imdb.rating" ],
               sortBy: { "imdb.rating": -1, title: 1 },
               n: 3
            }
         }
      }
   },
   {
      $sort: { _id: 1 }
   },
   {
      $limit: 5
   }
] )

[
  {
    _id: 'Action',
    lowestRatedMovie: [
      [ 'Starship: Rising', 2.1 ],
      [ 'House of the Dead', 2 ],
      [ 'Krampus: The Christmas Devil', 2 ]
    ]
  },
  {
    _id: 'Adventure',
    lowestRatedMovie: [
      [ 'Battlefield Earth', 2.4 ],
      [ 'Epic Movie', 2.3 ],
      [ 'Son of the Mask', 2.1 ]
    ]
  },
  {
    _id: 'Animation',
    lowestRatedMovie: [
      [ 'The Adventures of Rocky & Bullwinkle', 4.1 ],
      [ 'The King and I', 4 ],
      [ 'Space Chimps 2: Zartog Strikes Back', 2.7 ]
    ]
  },
  {
    _id: 'Biography',
    lowestRatedMovie: [
      [ 'Man in the Mirror: The Michael Jackson Story', 3.5 ],
      [ 'The Gaul', 2.7 ],
      [ 'The Undefeated', 2.3 ]
    ]
  },
  {
    _id: 'Comedy',
    lowestRatedMovie: [
      [ 'Superbabies: Baby Geniuses 2', 1.9 ],
      [ 'The Hottie & the Nottie', 1.9 ],
      [ 'Saving Christmas', 1.6 ]
    ]
  }
]

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 $bottomN 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 $bottomN para devolver las tres películas con menor puntuación para 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": { $exists: true }
      }
   },
   {
      $group:
         {
            _id: { rated: "$rated" },
            movies:
               {
                  $bottomN:
                     {
                        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: 'Justin Bieber: Never Say Never', rating: 1.6 } ]
  },
  {
    _id: { rated: 'PG' },
    movies: [
      { title: 'Superbabies: Baby Geniuses 2', rating: 1.9 },
      { title: "Justin Bieber's Believe", rating: 1.6 },
      { title: 'Saving Christmas', rating: 1.6 }
    ]
  },
  {
    _id: { rated: 'PG-13' },
    movies: [ { title: 'The Hottie & the Nottie', rating: 1.9 } ]
  },
  { _id: { rated: 'R' }, movies: [ { title: 'House of the Dead', rating: 2 } ] }
]

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 $bottomN 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 n películas con peor puntuación según IMDb.
Ordena los resultados alfabéticamente por clasificación de contenido.

Obtén más información

Volver

$bottom

$count