Wie man die letzten N Datensätze in mongodb?

Ich kann nicht finden, überall, es wurde dokumentiert diese. Standardmäßig wird die find () - operation erhalten die Aufzeichnungen von Anfang an. Wie bekomme ich die letzten N Datensätze in mongodb?

Edit: ich möchte auch das Ergebnis bestellt weniger aktuell auf dem neuesten, nicht Umgekehrt.

plase spezifisch zu beantworten, welcher Teil der web-Seite löst meine Frage?
Hi @BinChen, ich habe das gleiche problem vor kurzem, ist es gelöst?

InformationsquelleAutor Bin Chen | 2010-12-12

mongodb record

634

Wenn ich Ihre Frage zu verstehen, müssen Sie, um eine Sortierung in aufsteigender Reihenfolge.

Vorausgesetzt, Sie haben einige id oder Datum Feld namens "x", die Sie tun würde ...

.sort()
```
db.foo.find().sort({x:1});
```
Den 1 wird aufsteigend Sortieren (älteste bis neueste) und -1 wird absteigend Sortieren (neueste zuerst) aufgeführt.)

Wenn Sie das auto erstellt _id Feld hat Sie ein date eingebettet in..., so können Sie zur Bestellung von ...
```
db.foo.find().sort({_id:1});
```
Dass zurück alle Ihre Dokumente in der Reihenfolge vom ältesten zum neuesten.

Natürliche Ordnung

Können Sie auch einen Natürliche Ordnung oben genannten ...
```
db.foo.find().sort({$natural:1});
```
Wieder mit 1 oder -1 je nach der Reihenfolge, die Sie wollen.

Verwenden .limit()

Schließlich, es ist gute Praxis, fügen Sie eine Grenze, wenn Sie diese Art von weit offen-Abfrage, so dass Sie könnte entweder ...
```
db.foo.find().sort({_id:1}).limit(50);
```
oder
```
db.foo.find().sort({$natural:1}).limit(50);
```
- Dieser Ansatz funktioniert nicht, wenn ich skip verwenden, und begrenzen mit:Item.finden().Sortieren('date',-1).überspringen Sie(start).limit(Grenzwert).laufen(cb); Es sollte die Zeilen zu Sortieren und überspringen Sie dann die ersten N Zeilen. aber es überspringt die ersten N Zeilen und sortiert dann die blieb.
- Ich bin mir ziemlich sicher, haben Sie Ihre Abfrage, um Durcheinander ... Ihr sort() ausgeführt werden soll, die Letzte, nicht die erste (ähnlich wie ein SQL-ORDER BY) .find({}).skip(1).limit(50).sort({"date":-1})
- Was immer es ist, die um Funktionen aufzurufen, haben sollte nichts zu tun mit dem Endergebnis.
- Antwort noch aktuell in 2013
- Natürlich, die Reihenfolge ist wichtig. item = 3; item.add(3).divide(3) == 2; item.divide(3).add(3) == 4; Ohne Auftrag, was wäre das Ergebnis??? Ich Stimme mit Ihnen überein, dass diese umgekehrte Reihenfolge ist nicht intuitiv. Das ist kein SQL, nachdem alle sollte Sie normal OO Paradigmen.
- und doch, die Reihenfolge SPIELT KEINE Rolle. Alles was Sie tun müssen, ist zu versuchen, es zu sehen, dass es nicht. alle sind aufgerufen, der cursor und an den server übergeben, damit der server begrenzt die Ergebnisse der sort (top-N), alles andere würde keinen Sinn machen.
- Docs bestätigen, dass die Reihenfolge spielt keine Rolle: link
- Nicht MongoDB speichern Sie das Dokument in der eingelegten Reihenfolge? (Objekt-id aufsteigend)?
- Sobald Sie das tun db.foo.find().sort({$natural:-1}).limit(50); bekommen Sie die letzten 50 Einträge in absteigender Weise. Wie können wir optimal die Reihenfolge ändern, aufsteigend?
- vielleicht fügen Sie manuelle .to_a.sort_by { |doc| doc.id } danach? Oder verwenden Sie moped-Funktionen direkt und es neu anordnen.
- Jenkins - das ist schrecklich in Bezug auf Leistung, wenn Sie eine Tabelle mit LOOOOOOTS der Rekorde.
- was bedeutet "LOOOOOOTS" bedeuten? Ich habe Sammlungen mit 100s von Millionen von Dokumente, aber vielleicht ist das nicht viel zu Ihnen. Als Faustregel gilt: sobald Sie sprechen über das Abfragen von Dokumenten zu jeder Art von Skala sollten Sie die Erstellung von Indizes auf die Taste, die Sie möchten Sie die Abfrage auf. 🙂
- Jenkins, Wenn es gut funktioniert für 100s von Millionen hat, um die Verwendung einer indizierten Feld für: "Vorausgesetzt, Sie haben einige id oder Datum Feld namens "x" würden Sie...", aber ich wollte nicht sehen, Sie erwähnen es. Hast du ein indiziertes Feld gibt es?
- Für pymongo, siehe die Antwort
- die Reihenfolge der skip/limit/Art egal: "die Reihenfolge, in der Kette die Grenze() und sort () - Methoden ist nicht signifikant" "Kombinieren Cursor-Methoden". Jede verkettete Methoden auf das Cursor-Objekt ändern den cursor vor alle Datensätze erhalten werden; MongoDB wird die korrekte Reihenfolge der skip/limit/sort-Parameter intuitiv.
- sollte dies nicht akzeptiert werden, da die Antwort, wie es nicht actaully tun, was die OP gefragt, speziell: 'Holen Sie sich die letzten N Datensätze" und "Ergebnis aus bestellt weniger aktuell auf dem neuesten, nicht Umgekehrt'. Diese Lösung wird zu Lesen bekommen N Datensätze aus dem Schwanz, aber er wird verlieren, es ist aufsteigender Reihenfolge aufgrund der erstmaligen Bestellung operation, die bedeutet, dass Sie brauchen, um neu -, um die Ergebnisse zurück zur Natur : 1 um
- Gute Erklärung
- Natürliche Ordnung sollte nicht verlassen werden; wenn Sie eine Replikatgruppe (und Sie sein sollte), verschiedene Knoten könnten auch die gleichen Dokumente in einer anderen Reihenfolge auf der Festplatte.
- Datum Teil im auto erstellt _id ist ein Teil _id und es kann nicht verwendet werden, für die 100% Genauigkeit zu Sortieren nach Datum. Es funktioniert nur, wenn Sie nie mehr als 1 schreiben/Sekunde docs.mongodb.com/manual/reference/method/ObjectId
- Bitte @João Otero 's Antwort, die Sie betrachtet, die Leistung also diese Antwort kann wirklich komplett
InformationsquelleAutor Justin Jenkins
100

Den letzten N zusätzlichen Aufzeichnungen, die von weniger aktuell zu den letzten, kann man mit dieser Abfrage:
```
db.collection.find().skip(db.collection.count() - N)
```
Wenn Sie wollen, dass Sie in der umgekehrten Reihenfolge:
```
db.collection.find().sort({ $natural: -1 }).limit(N)
```
Wenn Sie installieren Mongo-Hacker können Sie auch verwenden:
```
db.collection.find().reverse().limit(N)
```
Wenn Sie müde werden, schreiben Sie diese Befehle alle die Zeit, die Sie erstellen können benutzerdefinierte Funktionen in Ihre ~/.mongorc.js. E. g.
```
function last(N) {
    return db.collection.find().skip(db.collection.count() - N);
}
```
dann von einer mongo-shell geben Sie einfach last(N)
- db.collection.find().reverse().limit(1) gibt mir die Fehlermeldung ... has no method reverse
- du hast Recht, ich habe gerade festgestellt, dass reverse() wurde Hinzugefügt von [Mongo-Hacker ](tylerbrock.github.com/mongo-hacker), werde ich update meine Antwort. Danke.
- db.getCollection('COLLECTION_NAME').finden().skip(db.getCollection('COLLECTION_NAME').count()-N) funktioniert Super für mich 🙂
- Dies sollte die Antwort auf die Frage und nicht die Antwort von Justin Jenkins.
- Natürliche Ordnung sollte nicht verlassen werden; wenn Sie eine Replikatgruppe (und Sie sein sollte), verschiedene Knoten könnten auch die gleichen Dokumente in einer anderen Reihenfolge auf der Festplatte.
- Ist es möglich, dies zu tun in einem Aggregat suchen, wo Sie die letzten N Werte können mehrere Dokumente, die aggregiert?
InformationsquelleAutor Trasplazio Garzuglio
13

Um letzten N Datensätze, die Sie ausführen können, unten-Abfrage:
```
db.yourcollectionname.find({$query: {}, $orderby: {$natural : -1}}).limit(yournumber)
```
wenn Sie möchten, dass nur der Letzte Datensatz:
```
db.yourcollectionname.findOne({$query: {}, $orderby: {$natural : -1}})
```
Hinweis: In Ort der $Natur, die Sie können verwenden Sie eine der Spalten aus Ihrer Sammlung.
- dies funktioniert für mich db.yourcollectionname.findOne({$query:{}, $orderby : {$natural : -1}}). Ich denke, letzten parathensis fehlt in der Antwort
- Natürliche Ordnung sollte nicht verlassen werden; wenn Sie eine Replikatgruppe (und Sie sein sollte), verschiedene Knoten könnten auch die gleichen Dokumente in einer anderen Reihenfolge auf der Festplatte.
InformationsquelleAutor Ashwini
6

können Sie sort() , limit() ,skip() zu bekommen, letzten N Rekord-start von jedem übersprungen Wert
```
db.collections.find().sort(key:value).limit(int value).skip(some int value);
```
InformationsquelleAutor pkp
5

Schauen Sie unter Abfragen: Sortieren und Natürliche Ordnung, http://www.mongodb.org/display/DOCS/Sorting+und+Natur+Bestellen
ebenso wie sort (), die unter Cursor-Methoden
http://www.mongodb.org/display/DOCS/Advanced+Abfragen
- Vielen Dank für Ihre anwser, es ist nah,aber ich möchte retured records bestellt weniger aktuell jüngsten, ist es möglich?
- Natürliche Ordnung sollte nicht verlassen werden; wenn Sie eine Replikatgruppe (und Sie sein sollte), verschiedene Knoten könnten auch die gleichen Dokumente in einer anderen Reihenfolge auf der Festplatte.
- Wenn Sie möchten, um die neuesten Datensätze haben, müssen Sie verlassen sich auf ein Datum-Feld in das Dokument ein.
InformationsquelleAutor Steve Wilhelm
5

Kann man nicht "überspringen", basierend auf der Größe der Sammlung, denn es wird nicht die query-Bedingungen berücksichtigt werden.

Die richtige Lösung ist, um zu Sortieren von der gewünschten end-Punkt, der Begrenzung der Größe der Ergebnismenge, dann passen Sie die Reihenfolge der Ergebnisse, wenn nötig.

Hier ist ein Beispiel, basierend auf real-world-code.
```
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
        });
    }
});
```
- Netten workaround! Wäre schön, in der Lage, das gleiche zu tun auf der query-Ebene obwohl. So etwas wie var query = collection.find( { conditions } ).sort({$natural : -1}).reverse().limit(N).
InformationsquelleAutor Marty Hirsch
4

Können Sie versuchen, diese Methode:

Holen Sie sich die Gesamtanzahl der Datensätze in der Sammlung mit
```
db.dbcollection.count() 
```
Dann verwenden, überspringen:
```
db.dbcollection.find().skip(db.dbcollection.count() - 1).pretty()
```
InformationsquelleAutor bello hargbola
3

Sortieren, überspringen und so weiter können sehr langsam sein, abhängig von der Größe Ihrer Sammlung.

Einer besseren Leistung wäre dann erreicht, wenn Sie haben, Sie Sammlung indiziert durch einige Kriterien erfüllen; und dann können Sie min() cursor:

Ersten, index-Sammlung mit db.collectionName.setIndex( yourIndex )
Sie können auf-oder absteigend, das ist cool, denn Sie wollen immer das "N letzten Elemente"... also, wenn Sie index in absteigender Reihenfolge ist die gleiche wie immer die "ersten N Elemente".

Dann finden Sie den ersten Artikel Ihrer Sammlung und Nutzung Ihrer index-Feld Werte als min-Kriterien in eine Suche wie:
```
db.collectionName.find().min(minCriteria).hint(yourIndex).limit(N)
```
Hier ist die Referenz für min() cursor: https://docs.mongodb.com/manual/reference/method/cursor.min/
- Nur die Antwort, dass die Leistung in Betracht, tolle Ergänzung 🙂
- Bedeutet diese Antwort garantiert um?
- ja, basierend auf der Reihenfolge Ihres index
InformationsquelleAutor João Otero
2

Möchten Sie vielleicht, um mit der find Optionen :
http://docs.meteor.com/api/collections.html#Mongo-Collection-find
```
db.collection.find({}, {sort: {createdAt: -1}, skip:2, limit: 18}).fetch();
```
InformationsquelleAutor Lucbug

@bin-chen,

Können Sie eine aggregation für die Letzte n Einträge von a Teilmenge der Dokumente in der Sammlung. Hier ist ein Vereinfachtes Beispiel ohne Gruppierung (was Sie tun würde, die zwischen den Stufen 4 und 5 in diesem Fall).

Dieser gibt die letzten 20 Einträge (basierend auf einem Feld namens "timestamp"), aufsteigend sortiert. Es projiziert dann die einzelnen Dokumente _id, timestamp und whatever_field_you_want_to_show in das Ergebnis ein.

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

so, das Ergebnis würde folgendermaßen 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.

DANKE @lauri108! Alle Antworten auf diese und Verwandte Fragen, das ist DIE einzig funktionierende und zuverlässige Lösung ", wie man die LETZTEN " N "DOCS". Und einfach genug zu tun in einer Abfrage an. Job zu erledigen.

InformationsquelleAutor lauri108

0
```
db.collection.find().hint( { $natural : -1 } ).sort(field: 1/-1).limit(n)
```
laut mongoDB-Dokumentation:

Können Sie angeben { $natural : 1 } zu zwingen, die Abfrage zum ausführen einer vorwärts-Sammlung Scannen.

Können Sie auch angeben { $natural : -1 } um die Abfrage zu zwingen ausführen ein reverse-Sammlung Scannen.

InformationsquelleAutor Gili.il

verwenden $slice Betreiber zu begrenzen array-Elemente

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 ist array von Daten, aus, dass wir die 5 letzten Datensatz.

InformationsquelleAutor KARTHIKEYAN.A

-4

Letzte Funktion sollte sort, nicht limit.

Beispiel:
```
db.testcollection.find().limit(3).sort({timestamp:-1}); 
```
- Diese scheint nicht korrekt zu sein. Warum würde sort werden nach limit?
InformationsquelleAutor Ramesh Kasi

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

.sort()

Natürliche Ordnung

Verwenden .limit()