Wie bekomme ich die letzten N Datensätze in Mongodb?

Die letzten N hinzugefügten Datensätze, von den jüngsten bis zu den letzten, sind mit dieser Abfrage zu sehen:

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

Wenn Sie sie in umgekehrter Reihenfolge wünschen:

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

Wenn Sie Mongo-Hacker installieren, können Sie auch Folgendes verwenden:

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

Wenn Sie es satt haben, diese Befehle ständig zu schreiben, können Sie in Ihrem ~/.mongorc.js benutzerdefinierte Funktionen erstellen. Z.B.

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

dann von einer Mongo-Shell einfach last(N)

Um die letzten N Datensätze zu erhalten, können Sie folgende Abfrage ausführen:

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

wenn Sie nur einen letzten Datensatz wünschen:

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

Hinweis: Anstelle von $ natural können Sie eine der Spalten Ihrer Sammlung verwenden.

sie können sort(), limit(), skip() verwenden, um den letzten Start des N-Datensatzes von einem übersprungenen Wert zu erhalten 

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

Siehe unter Abfragen: Sortieren und natürliche Reihenfolge, http://www.mongodb.org/display/DOCS/Sorting+and+Natural+Order Sowie sort () unter Cursor Methods http://www.mongodb.org/display/DOCS/Advanced+Queries

Sie können nicht abhängig von der Größe der Sammlung "überspringen", da die Abfragebedingungen nicht berücksichtigt werden.

Die richtige Lösung ist, nach dem gewünschten Endpunkt zu sortieren, die Ergebnisgröße zu begrenzen und gegebenenfalls die Reihenfolge der Ergebnisse anzupassen. 

Hier ist ein Beispiel, das auf Code aus der realen Welt basiert.

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,

Sie können eine Aggregation für die letzten n Einträge einer Untermenge von Dokumenten in einer Sammlung verwenden. Hier ist ein vereinfachtes Beispiel ohne Gruppierung (was Sie in diesem Fall zwischen den Stufen 4 und 5 tun würden).

Dies gibt die letzten 20 Einträge zurück (basierend auf einem Feld mit dem Namen "Zeitstempel"), aufsteigend sortiert. Es projiziert dann jedes Dokument _id, Zeitmarke und whatever_field_you_want_to_show in die Ergebnisse.

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

das Ergebnis würde also ungefähr so ​​aussehen:

{ 
    "_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
}

Hoffe das hilft.

Möglicherweise möchten Sie die find-Optionen verwenden: http://docs.meteor.com/api/collections.html#Mongo-Collection-find

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

Sie können diese Methode ausprobieren:

Holen Sie sich die Gesamtzahl der Datensätze in der Sammlung mit 

db.dbcollection.count() 

Dann überspringen:

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

verwenden Sie den Operator $ slice , um Array-Elemente zu begrenzen 

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}` });
});

wo Geolocation ein Array von Daten ist, erhalten wir die letzten 5 Datensätze. 

Das Sortieren, Überspringen usw. kann abhängig von der Größe Ihrer Sammlung sehr langsam sein.

Eine bessere Leistung würde erreicht, wenn Sie Ihre Sammlung nach bestimmten Kriterien indexiert haben. und dann könnten Sie min () Cursor verwenden:

Indem Sie Ihre Sammlung mit db.collectionName.setIndex( yourIndex ) indexieren. Sie können die aufsteigende oder absteigende Reihenfolge verwenden, was cool ist, weil Sie immer die "N letzten Elemente" wünschen. Wenn Sie also in absteigender Reihenfolge indexieren, ist dies dasselbe wie das Abrufen der erste N Artikel ".

Dann finden Sie das erste Element Ihrer Sammlung und verwenden dessen Indexfeldwerte als Mindestkriterien in einer Suche wie:

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

Hier ist die Referenz für den Cursor min (): https://docs.mongodb.com/manual/reference/method/cursor.min/

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

laut mongoDB-Dokumentation :

Sie können {$ natural: 1} angeben, um zu erzwingen, dass die Abfrage einen Forward-Collection-Scan durchführt.

Sie können auch {$ natural: -1} angeben, um zu erzwingen, dass die Abfrage einen Reverse-Collection-Scan durchführt.