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

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

Você pode usar o acumulador $top para encontrar o filme mais bem avaliado de 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 para filtrar 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 os filmes dentro do grupo por classificação do IMDb em ordem decrescente, o que determina o filme que $top retorna.

Encontre a melhor classificação em várias classificações

Você pode usar o acumulador $top para encontrar o filme mais bem avaliado para cada categoria de classificação de filmes.

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 filtrar 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 com melhor classificação de 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 os filmes dentro de cada grupo por classificação do IMDb em ordem decrescente, o que determina o filme que $top retorna.

• Utiliza $sort para classificar os resultados alfabeticamente por categoria de classificação.