Menu Docs
Página inicial do Docs
/
Manual do MongoDB
/ / /

$lastN

Nesta página

  • Definição
  • Acumulador de agregação
  • Sintaxe
  • Comportamento
  • Restrições
  • Exemplos
  • Operador de array
  • Sintaxe
  • Comportamento
  • Exemplo

Novidades na versão 5.2.

$lastN pode ser usado como acumulador de agregação ou operador de array. Como um acumulador de agregação, é uma agregação dos últimos n elementos dentro de um grupo. Como operador de array, ele retorna o número especificado de elementos do final de uma array.

$lastN

Quando $lasttN é utilizado como acumulador de agregação, os elementos retornados serão significativos somente se estiverem em uma ordem de classificação especificada. Se o grupo tiver menos de n elementos, $lastN retornará todos os elementos no grupo.

{
$lastN:
{
input: <expression>,
n: <expression>
}
}
  • input especifica o(s) campo(s) do documento para obter os últimos n . A entrada pode ser qualquer expressão.

  • n deve ser uma expressão integral positiva que seja constante ou dependa do valor _id para $group. Para obter detalhes, consulte exemplo de chave de grupo.

  • $lastN não filtra valores nulos.

  • $lastN converte valores ausentes em nulo.

Considere a seguinte aggregation que retorna os últimos cinco documentos 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",
lastFiveScores:
{
$lastN:
{
input: "$score",
n: 5
}
}
}
}
] )

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.

  • O campo lastFiveScores é especificado utilizando input : "$score" e retornado como uma array.

  • Como não há critérios de classificação, os últimos 5 campos score são retornados.

[
{
_id: "G1",
lastFiveScores: [ 1, 2, 3, null, null ]
}
]

Os acumuladores $lastN e $bottomN podem realizar resultados semelhantes.

Em geral:

  • Se os documentos que chegam a $group já estiverem ordenados, você deverá usar $lastN.

  • Se você estiver classificando e selecionando os elementos n inferiores, poderá usar $bottomN para realizar ambas as tarefas com um acumulador.

  • $lastN pode ser utilizado como uma expressão de agregação, mas $bottomN não pode.

$lastN é suportada como uma expressão de agregação.

$lastN é suportado como um window operator.

Considere uma collection gamescores com os seguintes documentos:

db.gamescores.insertMany([
{ playerId: "PlayerA", gameId: "G1", score: 31 },
{ playerId: "PlayerB", gameId: "G1", score: 33 },
{ playerId: "PlayerC", gameId: "G1", score: 99 },
{ playerId: "PlayerD", gameId: "G1", score: 1 },
{ playerId: "PlayerA", gameId: "G2", score: 10 },
{ playerId: "PlayerB", gameId: "G2", score: 14 },
{ playerId: "PlayerC", gameId: "G2", score: 66 },
{ playerId: "PlayerD", gameId: "G2", score: 80 }
])

Você pode usar o acumulador $lastN para encontrar as últimas três pontuações em um único jogo.

db.gamescores.aggregate( [
{
$match : { gameId : "G1" }
},
{
$group:
{
_id: "$gameId",
lastThreeScores:
{
$lastN:
{
input: ["$playerId", "$score"],
n:3
}
}
}
}
] )

O exemplo de pipeline:

  • Utiliza $match para filtrar os resultados em um único gameId. Neste caso, G1.

  • Utiliza $group para agrupar os resultados por gameId. Neste caso, G1.

  • Especifica os campos que são saídas do $lastN com output : ["$playerId"," $score"] .

  • Usa $lastN para retornar os últimos três documentos do jogo G1 com n : 3.

A operação retorna os seguintes resultados:

[
{
_id: "G1",
lastThreeScores: [ [ "PlayerB", 33 ], [ "PlayerC", 99 ], [ "PlayerD", 1 ] ]
}
]

Você pode usar o acumulador $lastN para encontrar os últimos n campos de entrada em cada jogo.

db.gamescores.aggregate( [
{
$group:
{
_id: "$gameId", playerId:
{
$lastN:
{
input: [ "$playerId","$score" ],
n: 3
}
}
}
}
] )

O exemplo de pipeline:

  • Utiliza $group para agrupar os resultados por gameId.

  • Usa $lastN para retornar os últimos três documentos de cada jogo com n: 3.

  • Especifica os campos que são entrada para $lastN com input : ["$playerId", "$score"].

A operação retorna os seguintes resultados:

[
{
_id: 'G2',
playerId: [ [ 'PlayerB', 14 ], [ 'PlayerC', 66 ], [ 'PlayerD', 80 ] ]
},
{
_id: 'G1',
playerId: [ [ 'PlayerB', 33 ], [ 'PlayerC', 99 ], [ 'PlayerD', 1 ] ]
}
]

O uso de um estágio $sort anteriormente no pipeline pode influenciar os resultados do acumulador $lastN .

Neste exemplo:

  • {$sort : { score : -1 } } classifica as pontuações mais altas para trás de cada grupo.

  • lastN retorna as três pontuações mais baixas de trás de cada grupo.

db.gamescores.aggregate( [
{ $sort : { score : -1 } },
{
$group:
{ _id: "$gameId", playerId:
{
$lastN:
{
input: [ "$playerId","$score" ],
n: 3
}
}
}
}
] )

A operação retorna os seguintes resultados:

[
{
_id: 'G2',
playerId: [ [ 'PlayerC', 66 ], [ 'PlayerB', 14 ], [ 'PlayerA', 10 ] ]
},
{
_id: 'G1',
playerId: [ [ 'PlayerB', 33 ], [ 'PlayerA', 31 ], [ 'PlayerD', 1 ] ]
}
]

Você também pode atribuir o valor de n dinamicamente. Neste exemplo, a expressão $cond é utilizada no campo gameId .

db.gamescores.aggregate([
{
$group:
{
_id: {"gameId": "$gameId"},
gamescores:
{
$lastN:
{
input: "$score",
n: { $cond: { if: {$eq: ["$gameId","G2"] }, then: 1, else: 3 } }
}
}
}
}
] )

O exemplo de pipeline:

  • Utiliza $group para agrupar os resultados por gameId.

  • Especifica os campos que entram para $lastN com input : "$score" .

  • Se gameId for G2 então n é 1, caso contrário n é 3.

A operação retorna os seguintes resultados:

[
{ _id: { gameId: "G1" }, gamescores: [ 33, 99, 1 ] },
{ _id: { gameId: "G2" }, gamescores: [ 80 ] }
]

Você também pode utilizar $lastN como uma expressão de agregação.

Neste exemplo:

  • $documents cria o documento literal que contém uma array de valores.

  • $project é usado para retornar a saída de $lastN.

  • _id é omitido da saída com _id : 0.

  • $lastN utiliza o array de entrada de [10, 20, 30, 40].

  • Os últimos três elementos do array são retornados para o documento de entrada.

db.aggregate( [
{
$documents: [
{ array: [10, 20, 30, 40] } ]
},
{ $project: {
lastThreeElements:{
$lastN:
{
input: "$array",
n: 3
}
}
}
}
] )

A operação retorna os seguintes resultados:

[ { lastThreeElements: [ 20, 30, 40 ] } ]
$lastN

$lastN tem a seguinte sintaxe:

{ $lastN: { n: <expression>, input: <expression> } }
Campo
Descrição
n
Uma expressão que é resolvida para um número inteiro positivo. O inteiro especifica o número de elementos da array que $lastN retorna.
input
Uma expressão que resolve a array da qual retornar elementos n.
  • $lastN retorna elementos na mesma ordem em que aparecem na array de entrada.

  • $lastN não filtra valores null na array de entrada.

  • Você não pode especificar um valor de n menor que 1.

  • Se o n especificado for maior ou igual ao número de elementos na array input, $lastN retornará a array input.

  • Se input resolver para um valor que não seja da array, a operação de agregação será executada.

A coleção games possui os seguintes documentos:

db.games.insertMany([
{ "playerId" : 1, "score" : [ 1, 2, 3 ] },
{ "playerId" : 2, "score" : [ 12, 90, 7, 89, 8 ] },
{ "playerId" : 3, "score" : [ null ] },
{ "playerId" : 4, "score" : [ ] },
{ "playerId" : 5, "score" : [ 1293, null, 3489, 9 ]},
{ "playerId" : 6, "score" : [ "12.1", 2, NumberLong("2090845886852"), 23 ]}
])

O exemplo seguinte utiliza o operador $lastN para recuperar as últimas três pontuações para cada jogador. As pontuações são retornadas no novo campo lastScores criado por $addFields.

db.games.aggregate([
{ $addFields: { lastScores: { $lastN: { n: 3, input: "$score" } } } }
])

A operação retorna os seguintes resultados:

[{
"playerId": 1,
"score": [ 1, 2, 3 ],
"lastScores": [ 1, 2, 3 ]
},
{
"playerId": 2,
"score": [ 12, 90, 7, 89, 8 ],
"lastScores": [ 7, 89, 8 ]
},
{
"playerId": 3,
"score": [ null ],
"lastScores": [ null ]
},
{
"playerId": 4,
"score": [ ],
"lastScores": [ ]
},
{
"playerId": 5,
"score": [ 1293, null, 3489, 9 ],
"lastScores": [ null, 3489, 9 ]
},
{
"playerId": 6,
"score": [ "12.1", 2, NumberLong("2090845886852"), 23 ],
"lastScores": [ 2, NumberLong("2090845886852"), 23 ]
}]

Dica

Veja também:

Voltar

$last