$minN (acumulador de agregación)

Tipo de resultado

Cuando $minN compara valores de diferentes tipos, el orden de los tipos sigue el orden de comparación BSON.

Valores nulos y faltantes

$minN filtra los valores nulos y ausentes.

Considere la siguiente agregación que devuelve los valores mínimos de n de un grupo:

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",
         minimumThreeScores:
            {
               $minN:
                  {
                     input: "$score",
                     n: 4
                  }
            }
      }
   }
] )

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. Ambos valores se ignoran.

• El campo minimumThreeScores se especifica como $minN con input : "$score" y se devuelve como una matriz.

• Dado que solo hay documentos 3 con scores, $minN devuelve los campos 3 score mínimos aunque n = 4.

[
   {
   _id: 'G1',
   minimumThreeScores: [ 1, 2, 3 ]
   }
]

Comparación de los acumuladores $minN y $bottomN

Tanto los acumuladores $minN como $bottomN devuelven valores n de un grupo, pero difieren en cómo determinan qué valores devolver.

• Utilice $minN cuando los valores que desea comparar sean los mismos que desea devolver. $minN selecciona los n valores más pequeños comparando las entradas directamente.

• Utilice $bottomN cuando desee definir el orden de clasificación por separado de la salida. $bottomN le permite especificar una clave sortBy para determinar qué documentos son "inferiores" y una expresión output para controlar qué valores devolver.

Encuentra las tres calificaciones mínimas para un solo género.

Puedes usar el acumulador $minN para encontrar las tres calificaciones más bajas de IMDb en un solo género.

db.movies.aggregate( [
   {
      $match: { genres: "Horror" }
   },
   {
      $group:
         {
            _id: "Horror",
            minThreeRatings:
               {
                  $minN:
                  {
                     input: "$imdb.rating",
                     n: 3
                  }
               }
         }
   }
] )

[ { _id: 'Horror', minThreeRatings: [ 2, 2, 2.2 ] } ]

La pipeline de ejemplo:

• Utiliza $match para filtrar los resultados a películas donde Horror está incluido en el array genres.

• Utiliza $group para agrupar todos los documentos coincidentes en un solo grupo.

• Especifica la entrada para $minN con input: "$imdb.rating".

• Utiliza $minN para devolver las tres entradas con la calificación más baja de IMDb para el género Horror con n: 3.

Encuentra las tres calificaciones mínimas en varios géneros.

Puedes usar el acumulador $minN para encontrar las calificaciones mínimas n de IMDb en cada género.

db.movies.aggregate( [
   {
      $unwind: "$genres"
   },
   {
      $group:
         {
            _id: "$genres",
            minThreeRatings:
               {
                  $minN:
                     {
                        input: "$imdb.rating",
                        n: 3
                     }
               }
         }
   },
   { $sort: { _id: 1 } },
   { $limit: 5 }
] )

[
  { _id: 'Action', minThreeRatings: [ 2, 2, 2.1 ] },
  { _id: 'Adventure', minThreeRatings: [ 2.1, 2.3, 2.4 ] },
  { _id: 'Animation', minThreeRatings: [ 2.7, 4, 4.1 ] },
  { _id: 'Biography', minThreeRatings: [ 2.3, 2.7, 3.5 ] },
  { _id: 'Comedy', minThreeRatings: [ 1.6, 1.9, 1.9 ] }
]

La pipeline de ejemplo:

• Utiliza $unwind para crear un documento separado para cada género en el array genres.

• Utiliza $group para agrupar los resultados por genres.

• Utiliza $minN para devolver las tres entradas con la calificación más baja de IMDb para cada género con n: 3.

• Especifica la entrada para $minN con input: "$imdb.rating".

• Utiliza $sort para ordenar los resultados alfabéticamente por género.

• Limita la salida a cinco documentos para mejorar la legibilidad.

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

Puedes asignar el valor de n dinámicamente. En este ejemplo, la expresión $cond se utiliza en el campo rated.

db.movies.aggregate( [
   { $match: { rated: { $in: [ "G", "PG", "PG-13", "R" ] } } },
   {
      $group:
         {
            _id: { "rated": "$rated" },
            minMovies:
               {
                  $minN:
                     {
                        input: "$imdb.rating",
                        n: { $cond: { if: { $eq: [ "$rated", "R" ] }, then: 3, else: 1 } }
                     }
               }
         }
   }
] )

[
  { _id: { rated: 'PG' }, minMovies: [ 1.6 ] },
  { _id: { rated: 'G' }, minMovies: [ 1.6 ] },
  { _id: { rated: 'R' }, minMovies: [ 2, 2.2, 2.2 ] },
  { _id: { rated: 'PG-13' }, minMovies: [ 1.9 ] }
]

La pipeline de ejemplo:

• Filtros para películas con calificaciones de G, PG, PG-13 o R.

• Agrupa las películas por rated (la clasificación por contenido).

• Especifica la entrada para $minN con input: "$imdb.rating".

• Utiliza la expresión $cond para devolver 3 entradas mínimas para películas con calificación R y 1 entrada mínima para todas las demás calificaciones.

En la salida, la calificación R devuelve entradas 3, mientras que las calificaciones G, PG y PG-13 devuelven cada una una entrada 1.