¿Cómo obtener los últimos N registros en mongodb?

No puedo encontrar ningún lugar donde se haya documentado esto. Por defecto, la operación find () obtendrá los registros desde el principio. ¿Cómo puedo obtener los últimos N registros en mongodb?

Editar: también quiero que el resultado devuelto esté ordenado de menos reciente a más reciente, no al revés.

Si entiendo su pregunta, debe ordenar en orden ascendente.

Suponiendo que tiene algún campo de identificación o fecha llamado "x" que haría ...

.ordenar()

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

El 1 ordenará ascendente (más antiguo a más reciente) y -1 ordenará descendente (más nuevo a más antiguo).

Si usa el campo _id creado automáticamente , tiene una fecha incrustada ... así que puede usarlo para ordenar por ...

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

Eso devolverá todos sus documentos ordenados del más antiguo al más nuevo.

Orden natural

También puede usar un orden natural mencionado anteriormente ...

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

Nuevamente, usando 1 o -1 dependiendo del orden que desee.

Utilice .limit ()

Por último, es una buena práctica agregar un límite al hacer este tipo de consulta abierta para que pueda hacer cualquiera ...

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

o

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

Los últimos N registros agregados, de menos recientes a más recientes, se pueden ver con esta consulta:

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

Si los quieres en el orden inverso:

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

Si instala Mongo-Hacker también puede usar:

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

Si se cansa de escribir estos comandos todo el tiempo, puede crear funciones personalizadas en su ~ / .mongorc.js. P.ej

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

luego de un shell de mongo simplemente escriba last(N)

Para obtener los últimos N registros, puede ejecutar la siguiente consulta:

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

si solo quieres un último registro:

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

Nota: en lugar de $ natural, puede usar una de las columnas de su colección.

se puede utilizar sort(), limit(), skip()para obtener la última N inicio de la grabación de cualquier valor omitido

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

Puedes probar este método:

Obtenga el número total de registros en la colección con

db.dbcollection.count() 

Luego usa skip:

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

Mire en Consulta: Clasificación y orden natural, http://www.mongodb.org/display/DOCS/Sorting+and+Natural+Order , así como sort () en Métodos de cursor http://www.mongodb.org/display / DOCS / Consultas avanzadas +

No puede "omitir" en función del tamaño de la colección, ya que no tendrá en cuenta las condiciones de consulta.

La solución correcta es ordenar desde el punto final deseado, limitar el tamaño del conjunto de resultados y luego ajustar el orden de los resultados si es necesario.

Aquí hay un ejemplo, basado en código del 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,

Puede usar una agregación para las últimas n entradas de un subconjunto de documentos en una colección. Aquí hay un ejemplo simplificado sin agrupación (que estaría haciendo entre las etapas 4 y 5 en este caso).

Esto devuelve las últimas 20 entradas (basadas en un campo llamado "marca de tiempo"), ordenadas de forma ascendente. Luego, proyecta cada documento _id, marca de tiempo y lo que sea_campo_que usted_quiere_para_ mostrar en los 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)
}

entonces, el resultado se vería así:

{ 
    "_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 esto ayude.

Ordenar, omitir, etc. puede ser bastante lento dependiendo del tamaño de su colección.

Se lograría un mejor rendimiento si tiene su colección indexada por algunos criterios; y luego podrías usar el cursor min ():

Primero, indexe su colección con db.collectionName.setIndex( yourIndex ) Puede usar el orden ascendente o descendente, lo cual es genial, porque siempre desea los "N últimos elementos" ... así que si indexa en orden descendente es lo mismo que obtener los "primeros N elementos" .

Luego, encuentra el primer elemento de su colección y utiliza sus valores de campo de índice como criterios mínimos en una búsqueda como:

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

Aquí está la referencia para el cursor min (): https://docs.mongodb.com/manual/reference/method/cursor.min/

Es posible que desee utilizar las findopciones: 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 acuerdo con la documentación de mongoDB :

Puede especificar {$ natural: 1} para forzar a la consulta a realizar una exploración de recopilación de reenvíos.

También puede especificar {$ natural: -1} para forzar a la consulta a realizar una exploración de recopilación inversa.

use el operador $ slice para limitar los elementos de la 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}` });
});

donde la geolocalización es una matriz de datos, de eso obtenemos los últimos 5 registros.

La última función debería ser sort, no limit.

Ejemplo:

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