Mongodb'da son N kayıtları nasıl alabilirim?

Bunu belgelediği hiçbir yerde bulamıyorum. Varsayılan olarak, find () işlemi kayıtları en baştan alır. Mongodb'daki son N kayıtlarını nasıl alabilirim?

Düzenleme: Ayrıca ben döndürülen sonuç daha az en son gelen sipariş, ters değil istiyorum.

Sorunuzu anlarsam artan düzende sıralamanız gerekir.

"X" adında bir kimlik veya tarih alanınız olduğunu varsayarsak ...

.çeşit()

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

1 artan sıralamak (eski yeni kadar) ve olacak -1 azalan sırada olacak (yeni eski için).

Otomatik oluşturulan _id alanını kullanırsanız, içine gömülü bir tarihi vardır ... böylece bunu sipariş vermek için kullanabilirsiniz ...

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

Bu, en eskiden en yeniye doğru sıralanan tüm dokümanlarınızı geri döndürür.

Doğal Düzen

Yukarıda belirtilen bir Doğal Düzeni de kullanabilirsiniz ...

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

Yine, istediğiniz sıraya bağlı olarak 1 veya -1'i kullanın .

.Limit () kullanın

Son olarak, bu tür geniş açık sorgu yaparken bir sınır eklemek iyi bir uygulamadır, böylece her ikisini de yapabilirsiniz ...

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

veya

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

Geçen N En son az eskiye doğru, kayıtları eklenen, bu sorgu ile görülebilir:

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

Onları ters sırada istiyorsanız:

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

Mongo-Hacker'ı yüklerseniz şunları da kullanabilirsiniz:

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

Bu komutları her zaman yazmaktan sıkılırsanız ~ / .mongorc.js dosyasında özel işlevler oluşturabilirsiniz. Örneğin

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

sonra bir mongo kabuğundan last(N)

Son N kaydı almak için aşağıdaki sorguyu yürütebilirsiniz:

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

yalnızca son bir kayıt istiyorsanız:

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

Not: $ natural yerine koleksiyonunuzdaki sütunlardan birini kullanabilirsiniz.

kullanabilirsiniz sort(), limit(), skip()herhangi Atlanan değerden son N rekor başlamaya

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

Bu yöntemi deneyebilirsiniz:

İle koleksiyondaki toplam kayıt sayısını alın

db.dbcollection.count() 

Sonra skip'i kullanın:

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

Sorgulama: Sıralama ve Doğal Düzen'e bakın, http://www.mongodb.org/display/DOCS/Sorting+and+Natural+Order ve İmleç Yöntemleri altında http://www.mongodb.org/display / DOKÜMANLAR / İleri + Sorgular

Sorgu koşullarını dikkate almayacağı için koleksiyonun boyutuna göre "atlayamazsınız".

Doğru çözüm, istenen bitiş noktasından sıralamak, sonuç kümesinin boyutunu sınırlamak, ardından gerekirse sonuçların sırasını ayarlamaktır.

İşte gerçek dünya koduna dayanan bir örnek.

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

Bir koleksiyondaki belge alt kümesinin en son n girdisi için bir toplama kullanabilirsiniz. İşte gruplandırılmadan basitleştirilmiş bir örnek (bu durumda aşama 4 ve 5 arasında yapacağınız).

Bu, artan olarak sıralanmış, en son 20 girişi ("zaman damgası" adı verilen bir alana göre) döndürür. Daha sonra _id, timetamp ve whatever_field_you_want_to_show belgelerini sonuçlara yansıtır.

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

böylece sonuç şöyle görünecektir:

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

Bu yardımcı olur umarım.

Sıralama, atlama vb. Koleksiyonunuzun boyutuna bağlı olarak oldukça yavaş olabilir.

Koleksiyonunuzun bazı ölçütlere göre dizine eklenmesi durumunda daha iyi bir performans elde edilir; ve sonra min () imlecini kullanabilirsiniz:

İlk olarak, koleksiyonunuzu dizine ekleyin db.collectionName.setIndex( yourIndex ) Artan veya azalan düzeni kullanabilirsiniz, bu da iyidir, çünkü her zaman "N son öğe" ... .

Ardından koleksiyonunuzun ilk öğesini bulursunuz ve dizin alanı değerlerini aşağıdaki gibi bir aramada min kriteri olarak kullanırsınız:

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

Min () imlecinin referansı: https://docs.mongodb.com/manual/reference/method/cursor.min/

findSeçenekleri kullanmak isteyebilirsiniz : 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)

mongoDB Belgelerine göre :

Sorguyu ileriye doğru toplama taraması yapmaya zorlamak için {$ natural: 1} belirtebilirsiniz.

Ayrıca sorguyu ters toplama taraması yapmaya zorlamak için {$ natural: -1} belirtebilirsiniz.

kullanım dizi öğelerini sınırlamak $ slice operatörünü

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

burada coğrafi konum veri dizisidir, bundan son 5 kayıt alırız.

Son işlev olmalı sort, değillimit .

Misal:

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