Como obter os últimos N registros no mongodb?

Não consigo encontrar em nenhum lugar onde isso tenha sido documentado. Por padrão, a operação find () fará com que os registros sejam iniciados. Como posso obter os últimos N registros no mongodb?

Edit: também quero que o resultado retornado seja ordenado de menos recente para o mais recente, não o inverso.

Se eu entendi sua pergunta, você precisa classificar em ordem crescente.

Supondo que você tenha algum campo de identificação ou data chamado "x", você faria ...

.ordenar()

db.foo.find().sort({x:1});

O 1 classificará ascendente (do mais antigo para o mais novo) e -1 classificará descendente (do mais recente para o mais antigo).

Se você usar o campo _id criado automaticamente, ele terá uma data incorporada ... para que você possa usá-lo para ordenar por ...

db.foo.find().sort({_id:1});

Isso retornará todos os seus documentos classificados do mais antigo para o mais novo.

Ordem natural

Você também pode usar uma ordem natural mencionada acima ...

db.foo.find().sort({$natural:1});

Novamente, use 1 ou -1, dependendo da ordem desejada.

Use .limit ()

Por fim, é uma boa prática adicionar um limite ao fazer esse tipo de consulta aberta, para que você possa ...

db.foo.find().sort({_id:1}).limit(50);

ou

db.foo.find().sort({$natural:1}).limit(50);

Os últimos N registros adicionados, do menos recente ao mais recente, podem ser vistos com esta consulta:

db.collection.find().skip(db.collection.count() - N)

Se você quiser na ordem inversa:

db.collection.find().sort({ $natural: -1 }).limit(N)

Se você instalar o Mongo-Hacker, também poderá usar:

db.collection.find().reverse().limit(N)

Se você se cansar de escrever esses comandos o tempo todo, poderá criar funções personalizadas no seu ~ / .mongorc.js. Por exemplo

function last(N) {
    return db.collection.find().skip(db.collection.count() - N);
}

então a partir de um shell mongo basta digitar last(N)

Para obter os últimos N registros, você pode executar a consulta abaixo:

db.yourcollectionname.find({$query: {}, $orderby: {$natural : -1}}).limit(yournumber)

se você quiser apenas um último registro:

db.yourcollectionname.findOne({$query: {}, $orderby: {$natural : -1}})

Nota: No lugar de $ natural, você pode usar uma das colunas da sua coleção.

você pode usar sort(), limit(), skip()para obter última N início registro de qualquer valor ignorado

db.collections.find().sort(key:value).limit(int value).skip(some int value);

Você pode tentar este método:

Obtenha o número total de registros na coleção com

db.dbcollection.count() 

Então use pular:

db.dbcollection.find().skip(db.dbcollection.count() - 1).pretty()

Procure em Consulta: Classificação e ordem natural, http://www.mongodb.org/display/DOCS/Sorting+and+Natural+Order , bem como sort () em Cursor Methods http://www.mongodb.org/display / DOCS / Avançado + Consultas

Você não pode "pular" com base no tamanho da coleção, porque ela não levará em consideração as condições da consulta.

A solução correta é classificar a partir do ponto final desejado, limitar o tamanho do conjunto de resultados e ajustar a ordem dos resultados, se necessário.

Aqui está um exemplo, com base no código do mundo real.

var query = collection.find( { conditions } ).sort({$natural : -1}).limit(N);

query.exec(function(err, results) {
    if (err) { 
    }
    else if (results.length == 0) {
    }
    else {
        results.reverse(); // put the results into the desired order
        results.forEach(function(result) {
            // do something with each result
        });
    }
});

@ bin-chen,

Você pode usar uma agregação para as n entradas mais recentes de um subconjunto de documentos em uma coleção. Aqui está um exemplo simplificado sem agrupamento (o que você faria entre os estágios 4 e 5 neste caso).

Isso retorna as 20 entradas mais recentes (com base em um campo chamado "registro de data e hora"), classificadas em ordem crescente. Em seguida, ele projeta cada documento _id, timestamp e qualquer que seja_field_you_want_to_show nos resultados.

var pipeline = [
        {
            "$match": { //stage 1: filter out a subset
                "first_field": "needs to have this value",
                "second_field": "needs to be this"
            }
        },
        {
            "$sort": { //stage 2: sort the remainder last-first
                "timestamp": -1
            }
        },
        {
            "$limit": 20 //stage 3: keep only 20 of the descending order subset
        },
        {
            "$sort": {
                "rt": 1 //stage 4: sort back to ascending order
            }
        },
        {
            "$project": { //stage 5: add any fields you want to show in your results
                "_id": 1,
                "timestamp" : 1,
                "whatever_field_you_want_to_show": 1
            }
        }
    ]

yourcollection.aggregate(pipeline, function resultCallBack(err, result) {
  // account for (err)
  // do something with (result)
}

portanto, o resultado seria algo como:

{ 
    "_id" : ObjectId("5ac5b878a1deg18asdafb060"),
    "timestamp" : "2018-04-05T05:47:37.045Z",
    "whatever_field_you_want_to_show" : -3.46000003814697
}
{ 
    "_id" : ObjectId("5ac5b878a1de1adsweafb05f"),
    "timestamp" : "2018-04-05T05:47:38.187Z",
    "whatever_field_you_want_to_show" : -4.13000011444092
}

Espero que isto ajude.

Classificar, pular etc. pode ser bem lento, dependendo do tamanho da sua coleção.

Um desempenho melhor seria alcançado se sua coleção fosse indexada por alguns critérios; e então você poderia usar o cursor min ():

Primeiro, indexe sua coleção com db.collectionName.setIndex( yourIndex ) Você pode usar ordem crescente ou decrescente, o que é legal, porque você deseja sempre os "N últimos itens" ... portanto, se você indexar por ordem decrescente, é o mesmo que obter os "primeiros N itens" .

Em seguida, você encontra o primeiro item da sua coleção e usa seus valores de campo de índice como os critérios mínimos em uma pesquisa como:

db.collectionName.find().min(minCriteria).hint(yourIndex).limit(N)

Aqui está a referência para o cursor min (): https://docs.mongodb.com/manual/reference/method/cursor.min/

Você pode usar as findopções: http://docs.meteor.com/api/collections.html#Mongo-Collection-find

db.collection.find({}, {sort: {createdAt: -1}, skip:2, limit: 18}).fetch();

db.collection.find().hint( { $natural : -1 } ).sort(field: 1/-1).limit(n)

de acordo com a documentação do mongoDB :

Você pode especificar {$ natural: 1} para forçar a consulta a executar uma varredura de coleção encaminhada.

Você também pode especificar {$ natural: -1} para forçar a consulta a executar uma verificação de coleção reversa.

use o operador $ slice para limitar os elementos da matriz

GeoLocation.find({},{name: 1, geolocation:{$slice: -5}})
    .then((result) => {
      res.json(result);
    })
    .catch((err) => {
      res.status(500).json({ success: false, msg: `Something went wrong. ${err}` });
});

onde geolocalização é uma matriz de dados, obtemos os últimos 5 registros.

A última função deve ser sort, não limit.

Exemplo:

db.testcollection.find().limit(3).sort({timestamp:-1});