/ /

$bottomN (operador acumulador )

Definição

$bottomN: Novidades na versão 5.2.
Retorna uma agregação dos elementos n menos importantes dentro de um grupo, de acordo com a ordem de classificação especificada. Se o grupo tiver menos de n elementos, $bottomN retornará todos os elementos no grupo.

Observação

Desambiguação

Esta página descreve $bottomN quando usado como acumulador. Os acumuladores retornam um valor agregado em um grupo de documentos de entrada.

Você também pode usar o $bottomN (window function), que retorna os elementos n inferiores de documentos em uma janela específica de acordo com a ordem de classificação especificada.

Sintaxe

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

Opções

Campo	necessidade	Descrição
`n`	Obrigatório	O número de elementos que `$bottomN` retorna do grupo. Para obter um exemplo de configuração n dinamicamente, consulte Definir n dinamicamente com base na chave de grupo.
`output`	Obrigatório	Determina a saída para cada elemento no grupo. Pode ser qualquer expressão.
`sortBy`	Obrigatório	Define a ordem de classificação dos elementos dentro de cada grupo, com sintaxe semelhante a `$sort`. Não afeta a ordem dos documentos na saída do pipeline.

Comportamento

Valores nulos e ausentes

$bottomN não filtra valores nulos.
$bottomN converte valores ausentes em nulo que são preservados na saída.

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

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.
Devido ao sortBy: { "score" : -1 }, os valores nulos são classificados no final da array playerId retornada.

[
   {
      _id: "G1",
      playerId: [ [ "PlayerA", 1 ], [ "PlayerD", null ], [ "PlayerE", null ] ]
   }
]

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.

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

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 literais da string são classificados antes da pontuação numérica PlayerA:

[
   {
      _id: "G1",
      playerId: [ [ "PlayerB", "2" ], [ "PlayerC", "" ], [ "PlayerA", 1 ] ]
   }
]

Exemplos

Os exemplos nesta página usam dados do conjunto de dados sample_mflix. Para obter detalhes sobre como carregar esse conjunto de dados em sua implantação autogerenciada do MongoDB , consulte Carregar o conjunto de dados de amostra. Se você fez modificações nos bancos de dados de amostra, talvez seja necessário descartar e recriar os bancos de dados para executar os exemplos nesta página.

Encontre os três filmes com classificação mais baixa em um único gênero

Você pode usar o acumulador $bottomN para encontrar os três filmes com classificação mais baixa no 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 ]
    ]
  }
]

O exemplo de pipeline:

Usa $match para restringir a entrada a filmes Short que incluem um valor imdb.rating.
Utiliza $group para colocar os filmes correspondentes em um único grupo Short.
Usa sortBy: { "imdb.rating": -1, title: 1 } para classificar filmes por classificação e usa title como desempate.
Especifica os campos retornados por $bottomN com output: [ "$title", "$imdb.rating" ].
Usa $bottomN para retornar os três filmes correspondentes inferiores com n: 3.

Encontre os filmes com classificação mais baixa de cada gênero

Você pode usar o acumulador $bottomN para encontrar os filmes com classificação mais baixa 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 ]
    ]
  }
]

O exemplo de pipeline:

Usa $unwind para expandir a array genres de cada filme.
Usa $match para manter apenas documentos que incluem um valor imdb.rating.
Utiliza $group para agrupar os resultados por gênero.
Especifica os campos retornados por $bottomN com output: [ "$title", "$imdb.rating" ].
Usa sortBy: { "imdb.rating": -1, title: 1 } para classificar filmes por classificação e usa title como um desempate determinístico.
Usa $bottomN para retornar os três filmes menos importantes de cada gênero com n: 3.
Usa $sort e $limit para mostrar os cinco primeiros gêneros alfabeticamente.

Definir n dinamicamente com base na chave do grupo

Você pode atribuir o valor de n dinamicamente. O exemplo a seguir usa a expressão $cond para retornar números diferentes de filmes com base na classificação do conteúdo.

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

O exemplo de pipeline:

Usa $match para manter apenas filmes com classificações de conteúdo G, PG, PG-13 ou R que incluem um valor de imdb.rating.
Utiliza $group para agrupar os resultados por classificação de conteúdo com _id: { rated: "$rated" }.
Especifica os campos retornados por $bottomN com output: { title: "$title", rating: "$imdb.rating" }.
Se a classificação do conteúdo for PG, então n é 3. Caso contrário, n é 1.
Usa sortBy: { "imdb.rating": -1 } para encontrar os filmes de menos n com base na pontuação do IMDb.
Classifica os resultados alfabeticamente por classificação de conteúdo.

Saiba mais

Voltar

$bottom

$count