创建一个自动递增的序列字段

A Counters Collection¶

Use a separate counters collection tracks the last number sequence used. The _id field contains the sequence name and the seq contains the last value of the sequence.

1. Insert into the counters collection, the initial value for the userid:

   db.counters.insert(
      {
         _id: "userid",
         seq: 0
      }
   )
   

2. Create a getNextSequence function that accepts a name of the sequence. The function uses the findAndModify() method to atomically increment the seq value and return this new value:

   function getNextSequence(name) {
      var ret = db.counters.findAndModify(
             {
               query: { _id: name },
               update: { $inc: { seq: 1 } },
               new: true
             }
      );
   
      return ret.seq;
   }
   

3. Use this getNextSequence() function during insert().

   db.users.insert(
      {
        _id: getNextSequence("userid"),
        name: "Sarah C."
      }
   )
   
   db.users.insert(
      {
        _id: getNextSequence("userid"),
        name: "Bob D."
      }
   )
   

   You can verify the results with find():

   db.users.find()
   

   The _id fields contain incrementing sequence values:

   {
     _id : 1,
     name : "Sarah C."
   }
   {
     _id : 2,
     name : "Bob D."
   }
   

function getNextSequence(name) {
   var ret = db.counters.findAndModify(
          {
            query: { _id: name },
            update: { $inc: { seq: 1 } },
            new: true,
            upsert: true
          }
   );

   return ret.seq;
}

Optimistic Loop¶

In this pattern, an Optimistic Loop calculates the incremented _id value and attempts to insert a document with the calculated _id value. If the insert is successful, the loop ends. Otherwise, the loop will iterate through possible _id values until the insert is successful.

1. Create a function named insertDocument that performs the “insert if not present” loop. The function wraps the insert() method and takes a doc and a targetCollection arguments.

   function insertDocument(doc, targetCollection) {
   
       while (1) {
   
           var cursor = targetCollection.find( {}, { _id: 1 } ).sort( { _id: -1 } ).limit(1);
   
           var seq = cursor.hasNext() ? cursor.next()._id + 1 : 1;
   
           doc._id = seq;
   
           targetCollection.insert(doc);
   
           var err = db.getLastErrorObj();
   
           if( err && err.code ) {
               if( err.code == 11000 /* dup key */ )
                   continue;
               else
                   print( "unexpected error inserting data: " + tojson( err ) );
           }
   
           break;
       }
   }
   

   The while (1) loop performs the following actions:

   • Queries the targetCollection for the document with the maximum _id value.
   • Determines the next sequence value for _id by:
     • adding 1 to the returned _id value if the returned cursor points to a document.
     • otherwise: it sets the next sequence value to 1 if the returned cursor points to no document.
   • For the doc to insert, set its _id field to the calculated sequence value seq.
   • Insert the doc into the targetCollection.
   • If the insert operation errors with duplicate key, repeat the loop. Otherwise, if the insert operation encounters some other error or if the operation succeeds, break out of the loop.

2. Use the insertDocument() function to perform an insert:

   var myCollection = db.users2;
   
   insertDocument(
      {
        name: "Grace H."
      },
      myCollection
   );
   
   insertDocument(
      {
        name: "Ted R."
      },
      myCollection
   )
   

   You can verify the results with find():

   db.users2.find()
   

   The _id fields contain incrementing sequence values:

   {
     _id: 1,
     name: "Grace H."
   }
   {
     _id : 2,
     "name" : "Ted R."
   }
   

The while loop may iterate many times in collections with larger insert volumes.