last - mongodb: ¿cómo obtener los últimos N registros?

mongodb show collection data

Question

No puedo encontrar en ningún lugar que haya sido documentado esto. De forma predeterminada, la operación find () obtendrá los registros desde el principio. ¿Cómo puedo obtener los últimos registros de N en mongodb?

Edición: también quiero que el resultado devuelto se ordene de menos reciente a más reciente, no a la inversa.

Answer 1

@ 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 (lo 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 en forma ascendente. Luego proyecta cada documento _id, timestamp y whatever_field_you_want_to_show 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)
}

así, el resultado se vería algo así 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 esto ayude.

Answer 2

Busque en Consultando: Ordenamiento y orden natural, http://www.mongodb.org/display/DOCS/Sorting+and+Natural+Order , así como sort () en Cursor Methods http://www.mongodb.org/display/DOCS/Advanced+Queries

Answer 3

Es posible que desee utilizar las opciones de find : http://docs.meteor.com/api/collections.html#Mongo-Collection-find

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

Answer 4

La última función debe ser sort , no limit .

Ejemplo:

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

Answer 5

Los últimos N registros agregados, de menos recientes a los 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, desde un shell mongo solo escribe last(N)

Answer 6

No puede "omitir" en función del tamaño de la colección, ya que no tendrá en cuenta las condiciones de la 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 el 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
        });
    }
});

Answer 7

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

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

Si quieres solo un último disco:

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

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

Answer 8

Si entiendo su pregunta, necesita ordenar en orden ascendente.

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

.ordenar()

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

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

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

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

Eso devolverá todos sus documentos ordenados de más antiguo a más nuevo.

Orden natural

También puedes usar una Orden Natural mencionada anteriormente ...

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

Nuevamente, usa 1 o -1 dependiendo del orden que quieras.

Utilice .limit ()

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

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

o

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

Answer 9

puede usar sort() , limit() , skip() para obtener el último inicio de registro N de cualquier valor omitido

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

Answer 10

usa 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 un conjunto de datos, de los cuales obtenemos los últimos 5 registros.

Answer 11

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

Según la documentación de mongoDB :

Puede especificar {$ natural: 1} para forzar a la consulta a realizar un análisis de recopilación de reenvíos.

También puede especificar {$ natural: -1} para forzar a la consulta a realizar un análisis de recopilación inversa.