$top (operador acumulador )

Valores nulos e ausentes

Considere a seguinte agregação que retorna o documento superior de um grupo de pontuações:

• $top não filtra valores nulos.

• $top converte valores ausentes em nulo.

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

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. Esses valores são considerados nulos.

• Os campos playerId e score são especificados como output : ["$playerId"," $score"] e retornados como valores de array.

• Especifique a ordem de classificação com sortBy: { "score": 1 }.

• PlayerD e PlayerE empatado para o elemento superior. PlayerD é retornado como o score superior.

• Para ter um comportamento de quebra de vínculo mais determinístico para vários valores nulos, adicione mais campos ao sortBy.

Ordenação de classificação do tipo de dados BSON

Ao classificar diferentes tipos, a ordem dos tipos de dados BSON é usada para determinar a ordem. Como exemplo, considere uma collection cujos valores consistem em strings e números.

• Em uma classificação crescente, os valores de string são classificados após valores numéricos.

• Em uma classificação decrescente, os valores de string são classificados antes dos valores numéricos.

Neste exemplo:

• PlayerA tem uma pontuação inteira.

• PlayerB tem uma pontuação de string "2" .

• PlayerC tem uma pontuação de string vazia.

Como a ordenação está em ordem decrescente { "score": -1 }, os valores string são ordenados antes da pontuação numérica de PlayerA. $top retorna o primeiro elemento após a ordenação, que é 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' ] } ]

Encontrar a melhor classificação em um gênero

Você pode usar o acumulador $top para encontrar o filme mais bem avaliado em um 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 ] }
]

O exemplo de pipeline:

• Usa $match como filtro para filmes de comédia com uma classificação IMDb positiva.

• Usa $group para agrupar todos os filmes de comédia em uma única chave de grupo "Comedy".

• Especifica os campos que são de saída para $top com output : ["$title", "$imdb.rating"].

• Usa sortBy: { "imdb.rating": -1 } para classificar filmes dentro do grupo por classificação IMDb em ordem decrescente, o que determina o filme que $top retorna.

Encontre a melhor classificação entre múltiplas avaliações

Você pode usar o acumulador $top para encontrar o filme com a melhor classificação para cada categoria de classificação de filme.

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

O exemplo de pipeline:

• Usa $match para filtro filmes nas categorias G, PG, PG-13 e R com uma classificação IMDb positiva.

• Utiliza $group para agrupar os resultados por rated.

• Usa $top para retornar o filme mais bem avaliado para cada categoria.

• Especifica os campos que são de saída para $top com output : ["$title", "$imdb.rating"].

• Usa sortBy: { "imdb.rating": -1 } para classificar filmes dentro de cada grupo por classificação IMDb em ordem decrescente, o que determina o filme que $top retorna.

• Usa $sort para classificar os resultados em ordem alfabética por categoria de classificação.