可以找到第一個或最後一個匹配嗎？

Question

我特別使用貓鼬，雖然我不相信那麼重要。例如，假設我有一個名爲MongoQueue的集合，並且我將幾個人添加到該隊列中。

`MongoQueue.save {function(err, firstPerson) { 
    if (err) console.log(err); 
    MongoQueue.save {function(err, secondPerson) { 
     if (err) console.log(err); 
     MongoQueue.save {function(err, thirdPerson) { 
     if (err) console.log(err); 
}}}` 

如何取回誰是第一個保存到MongoQueue的人嗎？或者.... mongoDB的findOne（）方法如何縮小它的搜索範圍？我可以指定findOne（）的行爲來選擇集合中最早的文檔嗎？或者我必須對集合進行排序（這將是最後的手段），如果是的話，我將如何按時間戳排序？

Answer 1

findOne()函數返回natural order中的文檔，這是磁盤上的順序。你不能指望這返回最近插入的文件。要返回最近最少插入的文檔，可以在_id上使用find（）函數進行反向排序並限制爲1，假定_id是爲您生成的默認ObjectId，或者是時間戳（_id部分構建，從一個時間戳，這就是爲什麼它與_id一起工作）。如果您使用_id（始終索引）或索引時間戳字段，這將非常快。

Answer 2

是的，您可以指定.findOne()的行爲，如本機驅動程序文檔中所示。唯一的區別是，在貓鼬的實現中，「選項」文件必須是是傳遞給該方法的「第三」參數。

所以，你可以提供一個「分類」規範此爲顯示在可用的選項：

Queue.findOne({ },null,{ "sort": { "_id": -1 } },function(err,doc) { 

只是爲了更多的信息，你可以在MongoDB的外殼採用以下做到這一點，利用$orderby查詢選項：

db.collection.findOne({ "$query": { }, "$orderby": { "_id": -1 } }) 

另外，.findOne()方法可以只返回一個文件，但它確實是就在.find()的包裝，因此所有的修飾符適用。包裝僅在返回的遊標上調用.next()，返回文檔並丟棄遊標。

此不再示例示出了其中本可以應用不同的方法：

var async = require('async'), 
    mongoose = require('mongoose'), 
    Schema = mongoose.Schema; 


mongoose.connect('mongodb://localhost/sequence'); 

var queueSchema = new Schema({ 
    name: String, 
    same: { type: String, default: "same" } 
}); 

var Queue = mongoose.model("Queue", queueSchema); 

var count = 0; 

async.series(
    [ 

    // Remove any documents 
    function(callback) { 
     Queue.remove(function(err) { 
     if (err) throw err; 
     callback(); 
     }); 
    }, 

    // Insert some new ones 
    function(callback) { 
     async.eachSeries(
     ["one","two","three"], 
     function(item,callback) { 
      var queue = new Queue({ name: item }); 
      queue.save(function(err,doc) { 
      if (err) throw err; 
      console.dir(doc); 
      callback(err,doc); 
      }); 
     }, 
     function(err) { 
      callback(err); 
     } 
    ); 
    }, 

    function(callback) { 
     async.whilst(
     function() { return count < 2 }, 
     function(callback) { 
      count++ 
      async.series(
      [ 
       // findOne is just the first one 
       function(callback) { 
       Queue.findOne({ "same": "same" },function(err,doc) { 
        if (err) throw err; 
        console.log("FindOne:\n%s", doc); 
        callback(); 
       }); 
       }, 

       // Or is sorted 
       function(callback) { 
       Queue.findOne(
        { "same": "same" }, 
        null, 
        { "sort": { "_id": -1 } }, 
        function(err,doc) { 
        if (err) throw err; 
        console.log("FindOne last:\n%s", doc); 
        callback(); 
        } 
       ); 
       }, 

       // find is ordered but not singular 
       function(callback) { 
       async.eachSeries(
        ["first","last"], 
        function(label,callback) { 
        var direction = (label == "first") ? 1 : -1; 
        var query = Queue.find({ "same": "same" }) 
         .sort({ "_id": direction }) 
         .limit(1); 
        query.exec(function(err,docs) { 
         if (err) throw err; 
         console.log(".find() %s:\n%s", label, docs[0]); 
         callback(); 
        }); 
        }, 
        function(err) { 
        callback(); 
        } 
       ); 
       }, 

       // findAndModify takes a sort 
       function(callback) { 
       Queue.findOneAndUpdate(
        { "same": "same" }, 
        { "$set": { "same": "different" } }, 
        { "sort": { "_id": -1 } }, 
        function(err,doc) { 
        if (err) throw err; 
        console.log("findOneAndUpdate:\n%s", doc); 
        callback(); 
        } 
       ); 
       } 

      ],function(err) { 
       callback(); 
      } 
     ); 
     }, 
     function(err) { 
      callback(); 
     } 
    ); 
    } 
    ],function(err) { 
    console.log("done");1 
    mongoose.disconnect(); 
    } 
);