mongodb: अंतिम एन रिकॉर्ड कैसे प्राप्त करें?




record (6)

मुझे कहीं भी यह दस्तावेज नहीं मिला है। डिफ़ॉल्ट रूप से, खोज () ऑपरेशन शुरुआत से रिकॉर्ड प्राप्त करेगा। मैं mongodb में अंतिम एन रिकॉर्ड कैसे प्राप्त कर सकता हूं?

संपादित करें: मैं भी लौटा परिणाम चाहता हूं कि हाल ही में हाल ही में हालिया से हाल ही में, रिवर्स नहीं।


@ बिन चेन,

आप संग्रह में दस्तावेज़ों के सबसेट की नवीनतम एन प्रविष्टियों के लिए एकत्रीकरण का उपयोग कर सकते हैं। ग्रुपिंग के बिना एक सरलीकृत उदाहरण यहां दिया गया है (जो आप इस मामले में चरण 4 और 5 के बीच कर रहे हैं)।

यह नवीनतम 20 प्रविष्टियों ("टाइमस्टैम्प" नामक फ़ील्ड के आधार पर) देता है, जो आरोही क्रमबद्ध होता है। इसके बाद परिणाम में प्रत्येक दस्तावेज़ _id, timestamp और जो भी_field_you_want_to_show प्रोजेक्ट करता है।

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

तो, परिणाम कुछ ऐसा दिखाई देगा:

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

उम्मीद है की यह मदद करेगा।


अंतिम एन रिकॉर्ड प्राप्त करने के लिए आप नीचे क्वेरी निष्पादित कर सकते हैं:

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

यदि आप केवल एक अंतिम रिकॉर्ड चाहते हैं:

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

नोट: $ प्राकृतिक के स्थान पर आप अपने संग्रह से कॉलम में से एक का उपयोग कर सकते हैं।


अगर मैं आपका प्रश्न समझता हूं, तो आपको आरोही क्रम में क्रमबद्ध करने की आवश्यकता है।

मान लें कि आपके पास "x" नामक कुछ आईडी या दिनांक फ़ील्ड है जो आप करेंगे ...

.sort ()

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

1 आरोही क्रमबद्ध करेगा (नवीनतम से सबसे पुराना) और -1 अवरोही क्रमबद्ध करेगा (सबसे पुराना सबसे पुराना।)

यदि आप ऑटो निर्मित _id फ़ील्ड का उपयोग करते हैं तो इसमें एक तिथि एम्बेड की गई है ... ताकि आप इसका उपयोग करके ऑर्डर कर सकें ...

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

इससे आपके सभी दस्तावेजों को सबसे पुराना से नवीनतम तक वापस कर दिया जाएगा।

स्वाभाविक विधान

आप ऊपर वर्णित एक प्राकृतिक आदेश का भी उपयोग कर सकते हैं ...

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

फिर, आपके इच्छित आदेश के आधार पर 1 या -1 का उपयोग करना।

.limit () का प्रयोग करें

अंत में, इस तरह की विस्तृत खुली क्वेरी करते समय सीमा जोड़ने का अच्छा अभ्यास है ताकि आप या तो कर सकें ...

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

या

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


आप संग्रह के आकार के आधार पर "छोड़ नहीं सकते", क्योंकि यह क्वेरी की स्थिति को ध्यान में रखेगा।

सही समाधान वांछित अंत-बिंदु से क्रमबद्ध करना है, परिणाम सेट के आकार को सीमित करें, फिर आवश्यक होने पर परिणामों के क्रम को समायोजित करें।

वास्तविक दुनिया कोड के आधार पर यहां एक उदाहरण दिया गया है।

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





record