$minN (acúmulo de agregação)

Tipo de resultado

Quando $minN compara valores de diferentes tipos, a ordem dos tipos segue a ordem de comparação BSON.

Valores nulos e ausentes

$minN filtra valores nulos e ausentes.

Considere a seguinte agregação que retorna os valores mínimos de n de um 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
                  }
            }
      }
   }
] )

Neste exemplo:

• $documents cria os documentos literais que contêm as pontuações dos jogadores.

• $group agrupa os documentos por gameId. Este exemplo tem apenas um gameId, G1.

• PlayerD tem uma pontuação ausente e PlayerE tem um nulo score. Estes valores são ignorados.

• O campo minimumThreeScores é especificado como $minN com input : "$score" e retornado como um array.

• Como há apenas 3 documentos com scores, $minN retorna o mínimo de 3 score campos, mesmo que n = 4.

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

Comparação de acumuladores de $minN e $bottomN

Ambos $minN e $bottomN acumuladores retornam n valores de um grupo, mas eles diferem na forma como determinam quais valores retornar.

• Use $minN quando os valores que você deseja comparar são os mesmos valores que você deseja retornar. $minN seleciona os n menores valores comparando as entradas diretamente.

• Use $bottomN quando você quiser definir a ordem de classificação separadamente da saída. $bottomN permite especificar uma chave sortBy para determinar quais documentos são "inferiores" e uma expressão output para controlar quais valores retornar.

Encontre o mínimo de três avaliações para um único gênero

Você pode usar o acumulador $minN para encontrar as três classificações IMDb mais baixas em um único 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 ] } ]

O exemplo de pipeline:

• Usa $match para filtro os resultados para filmes onde Horror está incluído no array genres.

• Usa $group para agrupar todos os documentos correspondentes em um único grupo.

• Especifica a entrada para $minN com input: "$imdb.rating".

• Usa $minN para retornar as três entradas com a classificação IMDb mais baixa para o gênero Horror com n: 3.

Encontrar as três menores avaliações em vários gêneros

Você pode usar o acumulador $minN para encontrar as n classificações mínimas do IMDb em 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 ] }
]

O exemplo de pipeline:

• Usa $unwind para criar um documento separado para cada gênero no array genres.

• Utiliza $group para agrupar os resultados por genres.

• Usa $minN para retornar as três entradas com a menor classificação IMDb para cada gênero com n: 3.

• Especifica a entrada para $minN com input: "$imdb.rating".

• Usa $sort para classificar os resultados em ordem alfabética por gênero.

• Limita a saída a cinco documentos para melhorar a legibilidade.

Definir n dinamicamente com base na chave de grupo

Você pode atribuir o valor de n dinamicamente. Neste exemplo, a expressão $cond é usada no 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 ] }
]

O exemplo de pipeline:

• Filtros para filmes com classificações de G, PG, PG-13 ou R.

• Agrupa filmes por rated (a classificação indicativa).

• Especifica a entrada para $minN com input: "$imdb.rating".

• Usa a expressão $cond para retornar 3 entradas mínimas para filmes com classificação Re 1 entrada mínima para todas as outras classificações.

Na saída, a classificação R retorna 3 entradas, enquanto as classificações G, PG e PG-13 retornam 1 entrada cada.