Comment obtenir les derniers enregistrements N dans mongodb?

Je ne trouve nulle part où cela a été documenté. Par défaut, l'opération find () récupère les enregistrements depuis le début. Comment puis-je obtenir les derniers N enregistrements dans mongodb?

Edit: je veux aussi que le résultat retourné soit ordonné du moins récent au plus récent, pas l'inverse.

Si je comprends votre question, vous devez trier par ordre croissant.

En supposant que vous ayez un champ id ou date appelé "x", vous feriez ...

.Trier()

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

Le 1 triera par ordre croissant (du plus ancien au plus récent) et -1 par ordre décroissant (du plus récent au plus ancien).

Si vous utilisez le champ _id créé automatiquement, il contient une date intégrée ... vous pouvez donc l'utiliser pour commander avant ...

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

Cela ramènera tous vos documents triés du plus ancien au plus récent.

Ordre naturel

Vous pouvez également utiliser un ordre naturel mentionné ci-dessus ...

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

Encore une fois, utilisez 1 ou -1 selon l'ordre que vous souhaitez.

Utilisez .limit ()

Enfin, il est recommandé d'ajouter une limite lors de ce type de requête grand ouvert afin que vous puissiez faire l'une ou l'autre ...

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

ou

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

Les N derniers enregistrements ajoutés, du moins récent au plus récent, peuvent être vus avec cette requête:

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

Si vous les voulez dans l'ordre inverse:

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

Si vous installez Mongo-Hacker, vous pouvez également utiliser:

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

Si vous en avez assez d'écrire ces commandes tout le temps, vous pouvez créer des fonctions personnalisées dans votre ~ / .mongorc.js. Par exemple

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

puis à partir d'un shell mongo il suffit de taper last(N)

Afin d'obtenir les N derniers enregistrements, vous pouvez exécuter la requête ci-dessous:

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

si vous ne voulez qu'un dernier enregistrement:

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

Remarque: au lieu de $ natural, vous pouvez utiliser l'une des colonnes de votre collection.

vous pouvez utiliser sort(), limit(), skip()pour obtenir début d'enregistrement dernier N de toute valeur sautée

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

Vous pouvez essayer cette méthode:

Obtenez le nombre total d'enregistrements dans la collection avec

db.dbcollection.count() 

Utilisez ensuite skip:

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

Regardez sous Querying: Sorting and Natural Order, http://www.mongodb.org/display/DOCS/Sorting+and+Natural+Order ainsi que sort () sous Cursor Methods http://www.mongodb.org/display / DOCS / Advanced + Requêtes

Vous ne pouvez pas "ignorer" en fonction de la taille de la collection, car elle ne tiendra pas compte des conditions de requête.

La bonne solution consiste à trier à partir du point final souhaité, à limiter la taille de l'ensemble de résultats, puis à ajuster l'ordre des résultats si nécessaire.

Voici un exemple, basé sur du code du monde réel.

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,

Vous pouvez utiliser une agrégation pour les n dernières entrées d'un sous-ensemble de documents dans une collection. Voici un exemple simplifié sans regroupement (ce que vous feriez entre les étapes 4 et 5 dans ce cas).

Cela renvoie les 20 dernières entrées (basées sur un champ appelé "horodatage"), triées par ordre croissant. Il projette ensuite chaque document _id, horodatage et tout_field_you_want_to_show dans les résultats.

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

ainsi, le résultat ressemblerait à quelque chose comme:

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

J'espère que cela t'aides.

Le tri, le saut, etc. peuvent être assez lents en fonction de la taille de votre collection.

Une meilleure performance serait obtenue si votre collection était indexée selon certains critères; puis vous pouvez utiliser le curseur min ():

Tout d'abord, indexez votre collection avec db.collectionName.setIndex( yourIndex ) Vous pouvez utiliser l'ordre croissant ou décroissant, ce qui est cool, car vous voulez toujours les "N derniers éléments" ... donc si vous indexez par ordre décroissant, c'est la même chose que d'obtenir les "premiers N éléments" .

Ensuite, vous trouvez le premier élément de votre collection et utilisez ses valeurs de champ d'index comme critères minimum dans une recherche comme:

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

Voici la référence pour le curseur min (): https://docs.mongodb.com/manual/reference/method/cursor.min/

Vous voudrez peut-être utiliser les findoptions: 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)

selon la documentation de mongoDB :

Vous pouvez spécifier {$ natural: 1} pour forcer la requête à effectuer une analyse de collecte vers l'avant.

Vous pouvez également spécifier {$ natural: -1} pour forcer la requête à effectuer une analyse de collection inverse.

utiliser l' opérateur $ slice pour limiter les éléments du tableau

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

où la géolocalisation est un tableau de données, d'où nous obtenons les 5 derniers enregistrements.

La dernière fonction devrait être sort, non limit.

Exemple:

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