Mongodb源码分析--插入记录及索引B树构建 .

  在之前的一篇文章 中，介绍了assembleResponse函数(位于instance.cpp第224行)，它会根据op操作枚举类型来调用相应的crud操作，枚举类型定义如下：

      enum  Operations {
        opReply  =   1 ,      /*  reply. responseTo is set.  */
        dbMsg  =   1000 ,     /*  generic msg command followed by a string  */
        dbUpdate  =   2001 ,  /*  update object  */
        dbInsert  =   2002 ,
         // dbGetByOID = 2003,
        dbQuery  =   2004 ,
        dbGetMore  =   2005 ,
        dbDelete  =   2006 ,
        dbKillCursors  =   2007
    };

    可以看到dbInsert = 2002 为插入操作枚举值，下面我们看一下assembleResponse在确定是插入操作时调用的方法，如下：

assembleResponse( Message  & m, DbResponse  & dbresponse,  const  SockAddr  & client ) {
    .....
             try  {
                 if  ( op  ==  dbInsert ) {   // 添加记录操作
                    receivedInsert(m, currentOp);
                }
                 else   if  ( op  ==  dbUpdate ) {  // 更新记录
                    receivedUpdate(m, currentOp);
                }
                 else   if  ( op  ==  dbDelete ) {  // 删除记录
                    receivedDelete(m, currentOp);
                }
                 else   if  ( op  ==  dbKillCursors ) {  // 删除Cursors（游标）对象
                    currentOp.ensureStarted();
                    logThreshold  =   10 ;
                    ss  <<   " killcursors  " ;
                    receivedKillCursors(m);
                }
                 else  {
                    mongo::log()  <<   "     operation isn't supported:  "   <<  op  <<  endl;
                    currentOp.done();
                    log  =   true ;
                }
            }
          .....
        }
    }

        从上面代码可以看出，系统在确定dbInsert操作时，调用了receivedInsert()方法（位于instance.cpp文件第570行），下面是该方法的定义：

void  receivedInsert(Message &  m, CurOp &  op) {
        DbMessage d(m); // 初始化数据库格式的消息
         const   char   * ns  =  d.getns(); // 获取名空间，用于接下来insert数据
        assert( * ns);
        uassert(  10058  ,   " not master " , isMasterNs( ns ) );
        op.debug().str  <<  ns;

        writelock lk(ns); // 声明写锁
        
         if  ( handlePossibleShardedMessage( m ,  0  ) ) // 查看是不是sharding信息，如果是则处理
             return ;

        Client::Context ctx(ns);
         int  n  =   0 ;
         while  ( d.moreJSObjs() ) {  // 循环获取当前消息体中的BSONObj数据（数据库记录）
            BSONObj js  =  d.nextJsObj();
            uassert(  10059  ,  " object to insert too large " , js.objsize()  <=  BSONObjMaxUserSize);
            {
                 //  声明BSONObj迭代器，以查看里面元素是否有更新操作，如set inc push pull 等
                BSONObjIterator i( js );
                 while  ( i.more() ) {
                    BSONElement e  =  i.next();
                    uassert(  13511  ,  " object to insert can't have $ modifiers "  , e.fieldName()[ 0 ]  !=   ' $ '  );
                }
            }
             // 插入记录操作，god = false用于标识当前BSONObj对象为有效数据
            theDataFileMgr.insertWithObjMod(ns, js,  false );
            logOp( " i " , ns, js); // 日志操作，包括master状态下及sharding分片情况

             if (  ++ n  %   4   ==   0  ) {
                 //  在插入一些数据后，进行持久化操作，有关持久化部分参见我的这篇文章
                 //   http://www.cnblogs.com/daizhj/archive/2011/03/21/1990344.html
                getDur().commitIfNeeded();
            }
        }
        globalOpCounters.incInsertInWriteLock(n); // 在写锁环境下添加已插入记录数（n）,锁采用InterlockedIncrement实现数的原子性
    }

      上面的方法中，主要是在“写锁”环境下执行插入数据操作，并且在插入记录之前进行简单的数据对象检查，如长度和插入数据是否被修改，以确保数据的最终有效性。
      最终上面代码会调用 insertWithObjMod()方法（位于pdfile.cpp 文件第1432行），该方法定义如下：

   DiskLoc DataFileMgr::insertWithObjMod( const   char   * ns, BSONObj  & o,  bool  god) {
        DiskLoc loc  =  insert( ns, o.objdata(), o.objsize(), god );
         if  (  ! loc.isNull() ) // 判断返回记录地址是否为空（记录是否插入成功）
            o  =  BSONObj( loc.rec() ); // 如有效，则用记录地地址上的记录(record类型指针)绑定到o上
         return  loc;
   }

      该方法只是一个对插入操作及返回结果的封装，其中ns为数据对象的名空间，o就是要插入的数据对象（BSONObj），god用于标识当前BSONObj 对象是否为有效数据（false=有效），这里之所以要传入god这个参数，是因为在接下来的insert方法里同时支持添加名空间(及索引)和插入记录操作（都会不断调用该方法），而在添加名空间时god=true。
    
     下面我们看一下insert方法（pdfile.cpp 第1467行），因为其内容较长，请详见注释：

DiskLoc DataFileMgr::insert( const   char   * ns,  const   void   * obuf,  int  len,  bool  god,  const  BSONElement  & writeId,  bool  mayAddIndex) {
         bool  wouldAddIndex  =   false ;
        massert(  10093  ,  " cannot insert into reserved $ collection " , god  ||  isANormalNSName( ns ) );
        uassert(  10094  , str::stream()  <<   " invalid ns:  "   <<  ns , isValidNS( ns ) );
         const   char   * sys  =  strstr(ns,  " system. " );
         if  ( sys ) { // 对插入记录的ns进行判断，是否要插入保留的数据库名(system)，如是则停止执行其它代码
            uassert(  10095  ,  " attempt to insert in reserved database name 'system' " , sys  !=  ns);
             if  ( strstr(ns,  " .system. " ) ) {
                 //  later:check for dba-type permissions here if have that at some point separate
                 if  ( strstr(ns,  " .system.indexes "  ) ) // 判断是否创建索引
                    wouldAddIndex  =   true ;
                 else   if  ( legalClientSystemNS( ns ,  true  ) )
                    ;
                 else   if  (  ! god ) { // 表示obuf有数据，但这就意味着要向system下插入数据（把system当成数据表了）
                     out ()  <<   " ERROR: attempt to insert in system namespace  "   <<  ns  <<  endl;
                     return  DiskLoc();
                }
            }
             else
                sys  =   0 ;
        }

         bool  addIndex  =  wouldAddIndex  &&  mayAddIndex; // 判断是否需要添加索引

        NamespaceDetails  * d  =  nsdetails(ns); // 获取ns的详细信息
         if  ( d  ==   0  ) {
            addNewNamespaceToCatalog(ns); // 向system catalog添加新的名空间，它会再次调用当前insert()方法
             /*  todo: shouldn't be in the namespace catalog until after the allocations here work.
               also if this is an addIndex, those checks should happen before this!
             */
             //  创建第一个数据库文件.
            cc().database() -> allocExtent(ns, Extent::initialSize(len),  false );
            d  =  nsdetails(ns);
             if  (  ! god )
                ensureIdIndexForNewNs(ns);
        }
        d -> paddingFits();

        NamespaceDetails  * tableToIndex  =   0 ;

         string  tabletoidxns;
        BSONObj fixedIndexObject;
         if  ( addIndex ) {
            assert( obuf );
            BSONObj io(( const   char   * ) obuf);
             // 做索引准备工作，这里并不真正创建索引，只是进行参数检查，以及索引是否已存在等
             if (  ! prepareToBuildIndex(io, god, tabletoidxns, tableToIndex, fixedIndexObject ) )
                 return  DiskLoc();

             if  (  !  fixedIndexObject.isEmpty() ) {
                obuf  =  fixedIndexObject.objdata();
                len  =  fixedIndexObject.objsize();
            }

        }

         const  BSONElement  * newId  =   & writeId;
         int  addID  =   0 ;
         if (  ! god ) {
             // 检查对象 是否有_id字段，没有则添加
             // Note that btree buckets which we insert aren't BSONObj's, but in that case god==true.      
            BSONObj io(( const   char   * ) obuf);
            BSONElement idField  =  io.getField(  " _id "  );
            uassert(  10099  ,   " _id cannot be an array " , idField.type()  !=  Array );

             if ( idField.eoo()  /* 判断是否是结束元素 */ &&   ! wouldAddIndex  &&  strstr(ns,  " .local. " )  ==   0  ) {
                addID  =  len;
                 if  ( writeId.eoo() ) {
                     //  初始化一个_id 随机值（因为_id可能是12 byte类型或其它类型）
                    idToInsert_.oid.init();
                    newId  =   & idToInsert; // 绑定初始化的_id值
                }
                len  +=  newId -> size();
            }
             // 如果io对象中有时间戳元素时，并用当前时间进行更新
            BSONElementManipulator::lookForTimestamps( io );
        }

         // 兼容旧的数据文件
        DiskLoc extentLoc;
         int  lenWHdr  =  len  +  Record::HeaderSize;
        lenWHdr  =  ( int ) (lenWHdr  *  d -> paddingFactor);
         if  ( lenWHdr  ==   0  ) {
            assert( d -> paddingFactor  ==   0  );
             * getDur().writing( & d -> paddingFactor)  =   1.0 ;
            lenWHdr  =  len  +  Record::HeaderSize;
        }

         //  在对新的对象分配空间前检查数据是否会造成索引冲突（唯一索引）
         //  capped标识是否是固定大小的集合类型，这种类型下系统会自动将过于陈旧的数据remove掉
         //  注：此cap与nosql中常说的cap无太大关联
         //      nosql cap即：一致性，有效性，分区容忍性
         //      参见这篇文章: http://blog.nosqlfan.com/html/1112.html ,
         //                   http://blog.nosqlfan.com/html/96.html )
         if  ( d -> nIndexes  &&  d -> capped  &&   ! god ) {
            checkNoIndexConflicts( d, BSONObj( reinterpret_cast < const   char   *> ( obuf ) ) );
        }

        DiskLoc loc  =  d -> alloc(ns, lenWHdr, extentLoc); // 为当前记录分配空间namespace.cpp __stdAlloc方法
         if  ( loc.isNull() ) { // 如果分配失效
             if  ( d -> capped  ==   0  ) {  //  cap大小未增加，即
                log( 1 )  <<   " allocating new extent for  "   <<  ns  <<   "  padding: "   <<  d -> paddingFactor  <<   "  lenWHdr:  "   <<  lenWHdr  <<  endl;
                 // 尝试从空闲空间列表中分配空间
                cc().database() -> allocExtent(ns, Extent::followupSize(lenWHdr, d -> lastExtentSize),  false );
                 // 尝试再次为当前记录分配空间
                loc  =  d -> alloc(ns, lenWHdr, extentLoc);
                 if  ( loc.isNull() ) {
                    log()  <<   " WARNING: alloc() failed after allocating new extent. lenWHdr:  "   <<  lenWHdr  <<   "  last extent size: "   <<  d -> lastExtentSize  <<   " ; trying again/n " ;
                     for  (  int  zzz = 0 ; zzz < 10   &&  lenWHdr  >  d -> lastExtentSize; zzz ++  ) { // 最多尝试循环10次分配空间
                        log()  <<   " try # "   <<  zzz  <<  endl;
                        cc().database() -> allocExtent(ns, Extent::followupSize(len, d -> lastExtentSize),  false );
                        loc  =  d -> alloc(ns, lenWHdr, extentLoc);
                         if  (  !  loc.isNull() )
                             break ;
                    }
                }
            }
             if  ( loc.isNull() ) { // 最终未分配空间给对象
                log()  <<   " insert: couldn't alloc space for object ns: "   <<  ns  <<   "  capped: "   <<  d -> capped  <<  endl;
                assert(d -> capped);
                 return  DiskLoc();
            }
        }

        Record  * r  =  loc.rec();
        {
            assert( r -> lengthWithHeaders  >=  lenWHdr );
            r  =  (Record * ) getDur().writingPtr(r, lenWHdr); // 持久化插入记录信息
             if ( addID ) {
                 /*  a little effort was made here to avoid a double copy when we add an ID  */
                (( int & ) * r -> data)  =   * (( int * ) obuf)  +  newId -> size();
                memcpy(r -> data + 4 , newId -> rawdata(), newId -> size()); // 拷贝_id字段到指定记录内存空间
                memcpy(r -> data + 4 + newId -> size(), (( char   * )obuf) + 4 , addID - 4 ); // 拷贝数据到指定内存空间
            }
             else  {
                 if ( obuf )
                    memcpy(r -> data, obuf, len); // 直接拷贝数据到记录字段r
            }
        }

        {
            Extent  * e  =  r -> myExtent(loc);
             if  ( e -> lastRecord.isNull() ) { // 如果未尾记录为空，本人理解：即之前未插入过记录
                Extent::FL  * fl  =  getDur().writing(e -> fl());
                fl -> firstRecord  =  fl -> lastRecord  =  loc;
                r -> prevOfs  =  r -> nextOfs  =  DiskLoc::NullOfs;
            }
             else  {
                Record  * oldlast  =  e -> lastRecord.rec(); // 否则将新记录添加到最后一条记录的后面
                r -> prevOfs  =  e -> lastRecord.getOfs();
                r -> nextOfs  =  DiskLoc::NullOfs;
                getDur().writingInt(oldlast -> nextOfs)  =  loc.getOfs();
                getDur().writingDiskLoc(e -> lastRecord)  =  loc;
            }
        }

         /*  持久化操作并更新相应统计信息  */
        {
            NamespaceDetails::Stats  * s  =  getDur().writing( & d -> stats);
            s -> datasize  +=  r -> netLength();
            s -> nrecords ++ ;
        }

         //  在god时会清空stats信息，同时会添加一个 btree bucket（占据存储空间）
         if  (  ! god )
            NamespaceDetailsTransient::get_w( ns ).notifyOfWriteOp(); // 在写操作时清空缓存，优化查询优化

         if  ( tableToIndex ) {
            uassert(  13143  ,  " can't create index on system.indexes "  , tabletoidxns.find(  " .system.indexes "  )  ==   string ::npos );

            BSONObj info  =  loc.obj();
             bool  background  =  info[ " background " ].trueValue();
             if ( background  &&  cc().isSyncThread() ) {
                 /*  don't do background indexing on slaves.  there are nuances.  this could be added later but requires more code. */
                log()  <<   " info: indexing in foreground on this replica; was a background index build on the primary "   <<  endl;
                background  =   false ;
            }

             int  idxNo  =  tableToIndex -> nIndexes;
            IndexDetails &  idx  =  tableToIndex -> addIndex(tabletoidxns.c_str(),  ! background);  //  清空临时缓存信息; 同时递增索引数量
            getDur().writingDiskLoc(idx.info)  =  loc;
             try  {
                buildAnIndex(tabletoidxns, tableToIndex, idx, idxNo, background); // 创建索引
            }
             catch ( DBException &  e ) {
                 //  保存异常信息，并执行dropIndexes
                LastError  * le  =  lastError. get ();
                 int  savecode  =   0 ;
                 string  saveerrmsg;
                 if  ( le ) {
                    savecode  =  le -> code;
                    saveerrmsg  =  le -> msg;
                }
                 else  {
                    savecode  =  e.getCode();
                    saveerrmsg  =  e.what();
                }

                 // 回滚索引操作(drop索引)
                 string  name  =  idx.indexName();
                BSONObjBuilder b;
                 string  errmsg;
                 bool  ok  =  dropIndexes(tableToIndex, tabletoidxns.c_str(), name.c_str(), errmsg, b,  true );
                 if (  ! ok ) {
                    log()  <<   " failed to drop index after a unique key error building it:  "   <<  errmsg  <<   '   '   <<  tabletoidxns  <<   '   '   <<  name  <<  endl;
                }

                assert( le  &&   ! saveerrmsg.empty() );
                raiseError(savecode,saveerrmsg.c_str());
                 throw ;
            }
        }

         /*  将记录数据添加到索引信息（btree）中  */
         if  ( d -> nIndexes ) {
             try  {
                BSONObj obj(r -> data);
                indexRecord(d, obj, loc);
            }
             catch ( AssertionException &  e ) {
                 //  _id index 键值重复
                 if ( tableToIndex  ||  d -> capped ) {
                    massert(  12583 ,  " unexpected index insertion failure on capped collection " ,  ! d -> capped );
                     string  s  =  e.toString();
                    s  +=   "  : on addIndex/capped - collection and its index will not match " ;
                    uassert_nothrow(s.c_str());
                    error()  <<  s  <<  endl;
                }
                 else  {
                     //  回滚上述操作
                    _deleteRecord(d, ns, r, loc);
                     throw ;
                }
            }
        }

         //   out() << "   inserted at loc:" << hex << loc.getOfs() << " lenwhdr:" << hex << lenWHdr << dec << ' ' << ns << endl;
         return  loc;
    }

     正如之前所说，该方法会完成添加名空间，添加索引，添加数据记录（memcpy调用）。其中名空间的添加方法addNewNamespaceToCatalog 比较简单，下面主要介绍一下索引的创建过程，这里分为了两步：

     1.创建索引树（b树）

     2.将数据（主要是地址）添加到索引（树）中

     先看一下创建索引过程：

static   void  buildAnIndex( string  ns, NamespaceDetails  * d, IndexDetails &  idx,  int  idxNo,  bool  background) {
        tlog()  <<   " building new index on  "   <<  idx.keyPattern()  <<   "  for  "   <<  ns  <<  ( background  ?   "  background "  :  ""  )  <<  endl;
        Timer t;
        unsigned  long   long  n;

         if ( background ) {
            log( 2 )  <<   " buildAnIndex: background=true/n " ;
        }

        assert(  ! BackgroundOperation::inProgForNs(ns.c_str()) );  //  should have been checked earlier, better not be...
        assert( d -> indexBuildInProgress  ==   0  );
        assertInWriteLock();
        RecoverableIndexState recoverable( d );
         if ( inDBRepair  ||   ! background ) { // 当数据库在repair时或非后台工作方式下
            n  =  fastBuildIndex(ns.c_str(), d, idx, idxNo); // 创建索引
            assert(  ! idx.head.isNull() );
        }
         else  {
            BackgroundIndexBuildJob j(ns.c_str()); // 以后台方式创建索引
            n  =  j.go(ns, d, idx, idxNo);
        }
        tlog()  <<   " done for  "   <<  n  <<   "  records  "   <<  t.millis()  /   1000.0   <<   " secs "   <<  endl;
    }

    创建索引方法会要据创建方式（是否是后台线程等），使用不同的方法，这里主要讲解非后台方式，也就是上面的fastBuildIndex方法（pdfile.cpp第1101行），其定义如下（内容详见注释）：
    

unsigned  long   long  fastBuildIndex( const   char   * ns, NamespaceDetails  * d, IndexDetails &  idx,  int  idxNo) {
        CurOp  *  op  =  cc().curop(); // 设置当前操作指针，用于设置操作信息

        Timer t;

        tlog( 1 )  <<   " fastBuildIndex  "   <<  ns  <<   "  idxNo: "   <<  idxNo  <<   '   '   <<  idx.info.obj().toString()  <<  endl;

         bool  dupsAllowed  =   ! idx.unique();
         bool  dropDups  =  idx.dropDups()  ||  inDBRepair;
        BSONObj order  =  idx.keyPattern();

        getDur().writingDiskLoc(idx.head).Null();

         if  ( logLevel  >   1  ) printMemInfo(  " before index start "  );

         /*  获取并排序所有键值 -----  */
        unsigned  long   long  n  =   0 ;
        shared_ptr < Cursor >  c  =  theDataFileMgr.findAll(ns);
        BSONObjExternalSorter sorter(order);
        sorter.hintNumObjects( d -> stats.nrecords );
        unsigned  long   long  nkeys  =   0 ;
        ProgressMeterHolder pm( op -> setMessage(  " index: (1/3) external sort "  , d -> stats.nrecords ,  10  ) );
         while  ( c -> ok() ) {
            BSONObj o  =  c -> current();
            DiskLoc loc  =  c -> currLoc();

            BSONObjSetDefaultOrder keys;
            idx.getKeysFromObject(o, keys); // 从对象中获取键值信息
             int  k  =   0 ;
             for  ( BSONObjSetDefaultOrder::iterator i = keys.begin(); i  !=  keys.end(); i ++  ) {
                 if (  ++ k  ==   2  ) { // 是否是多键索引
                    d -> setIndexIsMultikey(idxNo);
                }
                sorter.add( * i, loc); // 向排序器添加键值和记录位置信息
                nkeys ++ ;
            }

            c -> advance();
            n ++ ;
            pm.hit();
             if  ( logLevel  >   1   &&  n  %   10000   ==   0  ) {
                printMemInfo(  " /t iterating objects "  );
            }

        };
        pm.finished();

         if  ( logLevel  >   1  ) printMemInfo(  " before final sort "  );
        sorter.sort();
         if  ( logLevel  >   1  ) printMemInfo(  " after final sort "  );

        log(t.seconds()  >   5   ?   0  :  1 )  <<   " /t external sort used :  "   <<  sorter.numFiles()  <<   "  files  "   <<   "  in  "   <<  t.seconds()  <<   "  secs "   <<  endl;

        list < DiskLoc >  dupsToDrop;

         /*  创建索引  */
        {
            BtreeBuilder btBuilder(dupsAllowed, idx); // 实例化b树索引对象
             // BSONObj keyLast;
            auto_ptr < BSONObjExternalSorter::Iterator >  i  =  sorter.iterator(); // 初始化迭代器用于下面遍历
            assert( pm  ==  op -> setMessage(  " index: (2/3) btree bottom up "  , nkeys ,  10  ) );
             while ( i -> more() ) {
                RARELY killCurrentOp.checkForInterrupt(); // 检查冲突如shutdown或kill指令
                BSONObjExternalSorter::Data d  =  i -> next();

                 try  {
                    btBuilder.addKey(d.first, d.second); // 向b树索引对象中添加索引键值和记录位置信息
                }
                 catch ( AssertionException &  e ) {
                     if  ( dupsAllowed ) {
                         //  unknow exception??
                         throw ;
                    }

                     if ( e.interrupted() )
                         throw ;

                     if  (  !  dropDups )
                         throw ;

                     /*  we could queue these on disk, but normally there are very few dups, so instead we
                       keep in ram and have a limit.
                     */
                    dupsToDrop.push_back(d.second);
                    uassert(  10092  ,  " too may dups on index build with dropDups=true " , dupsToDrop.size()  <   1000000  );
                }
                pm.hit();
            }
            pm.finished();
            op -> setMessage(  " index: (3/3) btree-middle "  );
            log(t.seconds()  >   10   ?   0  :  1  )  <<   " /t done building bottom layer, going to commit "   <<  endl;
            btBuilder.commit(); // 提交创建索引操作，该方法会完成最终构造Btree索引操作
            wassert( btBuilder.getn()  ==  nkeys  ||  dropDups );
        }

        log( 1 )  <<   " /t fastBuildIndex dupsToDrop: "   <<  dupsToDrop.size()  <<  endl;
         // 删除索引中已出现的重复记录
         for ( list < DiskLoc > ::iterator i  =  dupsToDrop.begin(); i  !=  dupsToDrop.end(); i ++  )
            theDataFileMgr.deleteRecord( ns, i -> rec(),  * i,  false ,  true  );

         return  n;
    }

 

      上面方法主要对要创建的索引信息进行提取，并封装到一个BtreeBuilder中，顾名思义，该对象用于进行b树的创建(因为索引也是一个b树),当信息收集排序完成后，就开始创建索引，如下：

    btree.cpp 1842行
     void  BtreeBuilder::commit() {
        buildNextLevel(first);
        committed  =   true ;
    }

      void  BtreeBuilder::buildNextLevel(DiskLoc loc) {
         int  levels  =   1 ;
         while (  1  ) {
             if ( loc.btree() -> tempNext().isNull() ) {
                 //  在当前层级上只有一个 bucket
                getDur().writingDiskLoc(idx.head)  =  loc;
                 break ;
            }
            levels ++ ;

            DiskLoc upLoc  =  BtreeBucket::addBucket(idx); // 添加bucket并实例化上一层DiskLoc
            DiskLoc upStart  =  upLoc;
            BtreeBucket  * up  =  upLoc.btreemod(); // 获取上一层的bucket指针

            DiskLoc xloc  =  loc;
             while (  ! xloc.isNull() ) {
                RARELY {
                    getDur().commitIfNeeded();
                    b  =  cur.btreemod();
                    up  =  upLoc.btreemod();
                }

                BtreeBucket  * x  =  xloc.btreemod();
                BSONObj k;
                DiskLoc r;
                x -> popBack(r,k); // 弹出当前bucket中最右边的键
                 bool  keepX  =  ( x -> n  !=   0  ); // 当前bucket中元素个数是否为0
                DiskLoc keepLoc  =  keepX  ?  xloc : x -> nextChild;

                 // 压入上面弹出的最右边的键值，该键值为当前up（bucket）中最大值
                 if  (  !  up -> _pushBack(r, k, ordering, keepLoc) )
                {
                     //  当前 bucket 已满，则新创建一个addBucket
                    DiskLoc n  =  BtreeBucket::addBucket(idx);
                    up -> tempNext()  =  n;
                    upLoc  =  n;
                    up  =  upLoc.btreemod();
                    up -> pushBack(r, k, ordering, keepLoc);
                }

                DiskLoc nextLoc  =  x -> tempNext();  // get next in chain at current level
                 if  ( keepX ) { // 表示当前结点非顶层结点，则设置它的父结点
                    x -> parent  =  upLoc;
                }
                 else  {
                     if  (  ! x -> nextChild.isNull() )
                        x -> nextChild.btreemod() -> parent  =  upLoc;
                    x -> deallocBucket( xloc, idx ); // 删除xloc bucket
                }
                xloc  =  nextLoc; // 指向当前层的下个元素
            }

            loc  =  upStart; // 升级当前结点
            mayCommitProgressDurably();
        }

         if ( levels  >   1  )
            log( 2 )  <<   " btree levels:  "   <<  levels  <<  endl;
    }

    上面的buildNextLevel方法自下而上根据之前抽取的键值逐层构造一个b树。这里有一个问题需要注意一下，因为mongodb使用 bucket来作为b树中的一个层次结点或叶子结点容器（如下图），bucket最大尺寸为8192字节,c。有关b树索引的文章可以参见这篇文章 ：，
    mongodb目前关于B树索引的文档 ：http://blog.nosqlfan.com/html/758.html

      当初始化了b树索引及空间信息之后，下面就会将数据绑定到相应信息结点上了，也就是DataFileMgr::insert方法(pdfile.cpp文件)的如下代码：

/*  将记录数据添加到索引信息（btree）中  */

         if  ( d -> nIndexes ) {
             try  {
                BSONObj obj(r -> data);
                indexRecord(d, obj, loc);
            }
            ......
        } 

     上面的indexRecord方法会将键值和数据（包括存储位置）添加到索引中(其中参数d包括之前创建的B树索引信息), 该方法定义如下（pdfile.cpp 第1355行）:

/*  将键值和数据（包括存储位置）添加到索引中 */
     static   void  indexRecord(NamespaceDetails  * d, BSONObj obj, DiskLoc loc) {
         int  n  =  d -> nIndexesBeingBuilt(); // 获取已（及正在）构建的索引数
         for  (  int  i  =   0 ; i  <  n; i ++  ) {
             try  {
                 bool  unique  =  d -> idx(i).unique();
                 // 内联函数（inline）:将索引和记录相关信息初始化到btree中
                _indexRecord(d, i /* 索引顺序位 */ , obj, loc,  /* dupsAllowed */ ! unique);
            }
             catch ( DBException &  ) {
                 /*  如果发生异常，则进行回滚操作
                   note <= i (not < i) is important here as the index we were just attempted
                   may be multikey and require some cleanup.
                 */
                 for (  int  j  =   0 ; j  <=  i; j ++  ) {
                     try  {
                        _unindexRecord(d -> idx(j), obj, loc,  false );
                    }
                     catch (...) {
                        log( 3 )  <<   " unindex fails on rollback after unique failure/n " ;
                    }
                }
                 throw ;
            }
        }
    }

    上面的_indexRecord为内联函数（pdfile.cpp）（inline关键字参见C++说明），该参数声明如下：

  static  inline  void   _indexRecord(NamespaceDetails  * d,  int  idxNo, BSONObj &  obj, DiskLoc recordLoc,  bool  dupsAllowed) {
        IndexDetails &  idx  =  d -> idx(idxNo); //
        BSONObjSetDefaultOrder keys;
        idx.getKeysFromObject(obj, keys); // 从对象信息中获取键属性信息
        BSONObj order  =  idx.keyPattern();
        Ordering ordering  =  Ordering::make(order); // 初始化排序方式用于下面传参
         int  n  =   0 ;
         for  ( BSONObjSetDefaultOrder::iterator i = keys.begin(); i  !=  keys.end(); i ++  ) {
             if (  ++ n  ==   2  ) {
                d -> setIndexIsMultikey(idxNo); // 设置多键值索引
            }
            assert(  ! recordLoc.isNull() );
             try  {
                idx.head /* DiskLoc */ .btree() /* BtreeBucket */ -> bt_insert(idx.head, recordLoc,  // 执行向btree中添加记录和绑定索引信息的操作
                                             * i, ordering, dupsAllowed, idx);
            }
             catch  (AssertionException &  e) {
                 if ( e.getCode()  ==   10287   &&  idxNo  ==  d -> nIndexes ) {
                    DEV log()  <<   " info: caught key already in index on bg indexing (ok) "   <<  endl;
                     continue ;
                }
                 if (  ! dupsAllowed ) {
                     //  重复键值异常
                     throw ;
                }
                problem()  <<   "  caught assertion _indexRecord  "   <<  idx.indexNamespace()  <<  endl;
            }
        }
    }

    上面方法最终会执行b树插入方法bt_insert（btree.cpp文件1622行），如下（详情见注释）：

    int  BtreeBucket::bt_insert( const  DiskLoc thisLoc,  const  DiskLoc recordLoc,
                                const  BSONObj &  key,  const  Ordering  & order,  bool  dupsAllowed,
                               IndexDetails &  idx,  bool  toplevel)  const  {
         if  ( toplevel ) { // 如果是顶级节点（如果是通过构造索引方式调用 ，则toplevel=true）
             // 判断键值是否过界（因为其会存储在system.indexs中），其中：KeyMax = 8192 / 10 .mongodb开发团队可能会在更高版本中扩大该值
             if  ( key.objsize()  >  KeyMax ) {
                problem()  <<   " Btree::insert: key too large to index, skipping  "   <<  idx.indexNamespace()  <<   '   '   <<  key.objsize()  <<   '   '   <<  key.toString()  <<  endl;
                 return   3 ;
            }
        }
         // 执行添加操作
         int  x  =  _insert(thisLoc, recordLoc, key, order, dupsAllowed, DiskLoc(), DiskLoc(), idx);
        assertValid( order ); // assert排序方式是否有效

         return  x;
    }

    上面代码紧接着会调用btree.cpp文件的内部方法_insert（btree.cpp文件 1554行）：

    int  BtreeBucket::_insert( const  DiskLoc thisLoc,  const  DiskLoc recordLoc,
                              const  BSONObj &  key,  const  Ordering  & order,  bool  dupsAllowed,
                              const  DiskLoc lChild,  const  DiskLoc rChild, IndexDetails &  idx)  const  {
         if  ( key.objsize()  >  KeyMax ) {
            problem()  <<   " ERROR: key too large len: "   <<  key.objsize()  <<   "  max: "   <<  KeyMax  <<   '   '   <<  key.objsize()  <<   '   '   <<  idx.indexNamespace()  <<  endl;
             return   2 ;
        }
        assert( key.objsize()  >   0  );

         int  pos;
         // 在btree bucket中使用二分查询，查看键值是否已在所索引信息中
         bool  found  =  find(idx, key, recordLoc, order, pos  /* 返回该索引信息所在或应该在的位置 */ ,  ! dupsAllowed);
         if  ( insert_debug ) {
             out ()  <<   "    "   <<  thisLoc.toString()  <<   ' . '   <<   " _insert  "   <<
                  key.toString()  <<   ' / '   <<  recordLoc.toString()  <<
                   "  l: "   <<  lChild.toString()  <<   "  r: "   <<  rChild.toString()  <<  endl;
             out ()  <<   "     found: "   <<  found  <<   "  pos: "   <<  pos  <<   "  n: "   <<  n  <<  endl;
        }

         if  ( found ) {
             const  _KeyNode &  kn  =  k(pos); // 获取指定磁盘位置的节点信息，_KeyNode
             if  ( kn.isUnused() ) { // 查看已存在的键结点是否已使用
                log( 4 )  <<   " btree _insert: reusing unused key "   <<  endl;
                massert(  10285  ,  " _insert: reuse key but lchild is not null " , lChild.isNull());
                massert(  10286  ,  " _insert: reuse key but rchild is not null " , rChild.isNull());
                kn.writing().setUsed();
                 return   0 ;
            }

            DEV {
                log()  <<   " _insert(): key already exists in index (ok for background:true)/n " ;
                log()  <<   "    "   <<  idx.indexNamespace()  <<   "  thisLoc: "   <<  thisLoc.toString()  <<   ' /n ' ;
                log()  <<   "    "   <<  key.toString()  <<   ' /n ' ;
                log()  <<   "    "   <<   " recordLoc: "   <<  recordLoc.toString()  <<   "  pos: "   <<  pos  <<  endl;
                log()  <<   "   old l r:  "   <<  childForPos(pos).toString()  <<   '   '   <<  childForPos(pos + 1 ).toString()  <<  endl;
                log()  <<   "   new l r:  "   <<  lChild.toString()  <<   '   '   <<  rChild.toString()  <<  endl;
            }
            alreadyInIndex(); // 提示键值结点已在索引中，不必再创建，并抛出异常
        }

        DEBUGGING  out ()  <<   " TEMP: key:  "   <<  key.toString()  <<  endl;
        DiskLoc child  =  childForPos(pos); // 查询当前pos的子结点信息，以寻找插入位置
         if  ( insert_debug )
             out ()  <<   "     getChild( "   <<  pos  <<   " ):  "   <<  child.toString()  <<  endl;
         if  ( child.isNull()  ||   ! rChild.isNull()  /*  在当前buckets中插入，即 'internal' 插入  */  ) {
            insertHere(thisLoc, pos, recordLoc, key, order, lChild, rChild, idx); // 在当前buckets中插入
             return   0 ;
        }
         // 如果有子结点，则在子结点上执行插入操作
         return  child.btree() -> bt_insert(child, recordLoc, key, order, dupsAllowed, idx,  /* toplevel */ false );
    }

    上面_insert方法首先会使用二分法查找要插入的记录是否已存在于索引中，同时会返回一个插入点（pos），如不存在则会进一步在插入点位置查看找元素以决定是在当前bucket中插入，还是在当前pos位置的（右）子结点(bucket)上插入（这会再次递归调用上面的bt_insert方法），这里我们假定在当前bucket插入，则会执行insertHere方法（btree.cpp文件1183行），它的定义如下：
    

  /* *
     * insert a key in this bucket, splitting if necessary.
     * @keypos - where to insert the key in range 0..n.  0=make leftmost, n=make rightmost.
     * NOTE this function may free some data, and as a result the value passed for keypos may
     * be invalid after calling insertHere()
      */
     void  BtreeBucket::insertHere(  const  DiskLoc thisLoc,  int  keypos,
                                   const  DiskLoc recordLoc,  const  BSONObj &  key,  const  Ordering &  order,
                                   const  DiskLoc lchild,  const  DiskLoc rchild, IndexDetails &  idx)  const  {
         if  ( insert_debug )
             out ()  <<   "     "   <<  thisLoc.toString()  <<   " .insertHere  "   <<  key.toString()  <<   ' / '   <<  recordLoc.toString()  <<   '   '
                   <<  lchild.toString()  <<   '   '   <<  rchild.toString()  <<   "  keypos: "   <<  keypos  <<  endl;

        DiskLoc oldLoc  =  thisLoc;
         // 根据keypos插入相应位置并将数据memcpy到内存指定位置
         if  (  ! basicInsert(thisLoc, keypos, recordLoc, key, order) ) {
             // 如果插入无效，表示当前bucket已满，则分割记录并放到新创建的bucket中
            thisLoc.btreemod() -> split(thisLoc, keypos, recordLoc, key, order, lchild, rchild, idx);
             return ;
        }

        { // 持久化当前thisLoc的结点信息并根据插入位置（是否最后一个key），来更新当前thisLoc（及后面key结点）的子结点信息
             const  _KeyNode  * _kn  =   & k(keypos);
            _KeyNode  * kn  =  (_KeyNode  * ) getDur().alreadyDeclared((_KeyNode * ) _kn);  //  already declared intent in basicInsert()
             if  ( keypos + 1   ==  n ) {  //  n为pack（打包后）存储的记录数，这里"判断等于n"表示为最后(last)一个key
                 if  ( nextChild  !=  lchild ) { // 如果是最后元素，那么"当前最高键值的右子结点应该与要插入的左子结点相同
                     out ()  <<   " ERROR nextChild != lchild "   <<  endl;
                     out ()  <<   "   thisLoc:  "   <<  thisLoc.toString()  <<   '   '   <<  idx.indexNamespace()  <<  endl;
                     out ()  <<   "   keyPos:  "   <<  keypos  <<   "  n: "   <<  n  <<  endl;
                     out ()  <<   "   nextChild:  "   <<  nextChild.toString()  <<   "  lchild:  "   <<  lchild.toString()  <<  endl;
                     out ()  <<   "   recordLoc:  "   <<  recordLoc.toString()  <<   "  rchild:  "   <<  rchild.toString()  <<  endl;
                     out ()  <<   "   key:  "   <<  key.toString()  <<  endl;
                    dump();
                    assert( false );
                }
                kn -> prevChildBucket  =  nextChild; // "当前最高键值的右子结点”绑定到持久化结点的左子结点
                assert( kn -> prevChildBucket  ==  lchild );
                nextChild.writing()  =  rchild; // 持久化"当前最高键值的右子结点”，并将“要插入结点”的右子结点绑定到
                 if  (  ! rchild.isNull() ) // 如果有右子结点，则更新右子结点的父结点信息为当前thisLoc
                    rchild.btree() -> parent.writing()  =  thisLoc;
            }
             else  {
                 // 如果keypos位置不是最后一个
                kn -> prevChildBucket  =  lchild; // 将左子结点绑定到keypos位置结点的左子结点上
                 if  ( k(keypos + 1 ).prevChildBucket  !=  lchild ) { // 这时左子结点应该与下一个元素的左子结点相同
                     out ()  <<   " ERROR k(keypos+1).prevChildBucket != lchild "   <<  endl;
                     out ()  <<   "   thisLoc:  "   <<  thisLoc.toString()  <<   '   '   <<  idx.indexNamespace()  <<  endl;
                     out ()  <<   "   keyPos:  "   <<  keypos  <<   "  n: "   <<  n  <<  endl;
                     out ()  <<   "   k(keypos+1).pcb:  "   <<  k(keypos + 1 ).prevChildBucket.toString()  <<   "  lchild:  "   <<  lchild.toString()  <<  endl;
                     out ()  <<   "   recordLoc:  "   <<  recordLoc.toString()  <<   "  rchild:  "   <<  rchild.toString()  <<  endl;
                     out ()  <<   "   key:  "   <<  key.toString()  <<  endl;
                    dump();
                    assert( false );
                }
                 const  DiskLoc  * pc  =   & k(keypos + 1 ).prevChildBucket; // 获取keypos后面元素的左子结点信息
                 * getDur().alreadyDeclared((DiskLoc * ) pc)  =  rchild;  //  将右子结点绑定到下一个元素（keypos+1）的左子结点上declared in basicInsert()
                 if  (  ! rchild.isNull() ) // 如果有右子结点，则更新右子结点的父结点信息为当前thisLoc
                    rchild.btree() -> parent.writing()  =  thisLoc;
            }
             return ;
        }
    }

       该方法中会调用一个叫basicInsert的方法，它主要会在当前bucket中指定位置（keypos）添加记录信息，同时持久化该结点信息，如下：

// tree.cpp 1183
      bool  BucketBasics::basicInsert( const  DiskLoc thisLoc,  int   & keypos,  const  DiskLoc recordLoc,  const  BSONObj &  key,  const  Ordering  & order)  const  {
        assert( keypos  >=   0   &&  keypos  <=  n );
         // 判断bucket剩余的空间是否满足当前数据需要的存储空间
         int  bytesNeeded  =  key.objsize()  +   sizeof (_KeyNode);
         if  ( bytesNeeded  >  emptySize ) {
            _pack(thisLoc, order, keypos); // 如不够用，进行一次整理打包操作，以为bucket中整理更多空间
             if  ( bytesNeeded  >  emptySize ) // 如还不够用，则返回
                 return   false ;
        }

        BucketBasics  * b; // 声明Bucket管理对象指针，该对象提供了Bucket存储管理的基本操作和属性，如insert,_pack等
        {
             const   char   * p  =  ( const   char   * )  & k(keypos);
             const   char   * q  =  ( const   char   * )  & k(n + 1 );
             //  declare that we will write to [k(keypos),k(n)]
             //  todo: this writes a medium amount to the journal.  we may want to add a verb "shift" to the redo log so
             //        we can log a very small amount.
            b  =  (BucketBasics * ) getDur().writingAtOffset(( void   * )  this , p - ( char * ) this , q - p);
             // 如已有3个结点，目前要插到第三个结点之间，则对每三个元素进行迁移，
             //  e.g. n==3, keypos==2
             //  1 4 9
             //  ->
             //  1 4 _ 9
             for  (  int  j  =  n; j  >  keypos; j --  )  //  make room
                b -> k(j)  =  b -> k(j - 1 );
        }
        getDur().declareWriteIntent( & b -> emptySize,  12 );  //  [b->emptySize..b->n] is 12 bytes and we are going to write those
        b -> emptySize  -=   sizeof (_KeyNode); // 将当前bucket中的剩余空闲空间减少
        b -> n ++ ; // 已有结点数加1

        _KeyNode &  kn  =  b -> k(keypos);
        kn.prevChildBucket.Null(); // 设置当前结点的左子结点为空
        kn.recordLoc  =  recordLoc; // 绑定结点记录信息
        kn.setKeyDataOfs(( short ) b -> _alloc(key.objsize()) ); // 设置结点数据偏移信息
         char   * p  =  b -> dataAt(kn.keyDataOfs()); // 实例化指向磁盘数据(journal文件)位置（含偏移量）的指针
        getDur().declareWriteIntent(p, key.objsize()); // 持久化结点数据信息
        memcpy(p, key.objdata(), key.objsize()); // 将当前结点信息复制到p指向的地址空间
         return   true ;
    }

    如果上面方法调用失效，则意味着当前 bucket中已有可用空间插入新记录，这时系统会调用 split（btree.cpp文件 1240行）方法来进行bucket分割，以创建新的bucket并将信息塞入其中，如下：

     void  BtreeBucket::split( const  DiskLoc thisLoc,  int  keypos,  const  DiskLoc recordLoc,  const  BSONObj &  key,  const  Ordering &  order,  const  DiskLoc lchild,  const  DiskLoc rchild, IndexDetails &  idx) {
        assertWritable();

         if  ( split_debug )
             out ()  <<   "      "   <<  thisLoc.toString()  <<   " .split "   <<  endl;

         int  split  =  splitPos( keypos ); // 找到要迁移的数据位置
        DiskLoc rLoc  =  addBucket(idx); // 添加一个新的BtreeBucket
        BtreeBucket  * r  =  rLoc.btreemod();
         if  ( split_debug )
             out ()  <<   "      split: "   <<  split  <<   '   '   <<  keyNode(split).key.toString()  <<   "  n: "   <<  n  <<  endl;
         for  (  int  i  =  split + 1 ; i  <  n; i ++  ) {
            KeyNode kn  =  keyNode(i);
            r -> pushBack(kn.recordLoc, kn.key, order, kn.prevChildBucket); // 向新bucket中迁移过剩数据
        }
        r -> nextChild  =  nextChild; // 绑定新bucket的右子结点
        r -> assertValid( order );

         if  ( split_debug )
             out ()  <<   "      new rLoc: "   <<  rLoc.toString()  <<  endl;
        r  =   0 ;
        rLoc.btree() -> fixParentPtrs(rLoc); // 设置当前bucket树的父指针信息

        {
            KeyNode splitkey  =  keyNode(split); // 获取内存中分割点位置所存储的数据
            nextChild  =  splitkey.prevChildBucket;  //  提升splitkey 键，它的子结点将会是 thisLoc (l) 和 rLoc (r)
             if  ( split_debug ) {
                 out ()  <<   "     splitkey key: "   <<  splitkey.key.toString()  <<  endl;
            }

             //  将 splitkey 提升为父结点
             if  ( parent.isNull() ) {
                 //  如果无父结点时，则创建一个，并将
                DiskLoc L  =  addBucket(idx);
                BtreeBucket  * p  =  L.btreemod();
                p -> pushBack(splitkey.recordLoc, splitkey.key, order, thisLoc);
                p -> nextChild  =  rLoc; // 将分割的bucket为了当前
                p -> assertValid( order );
                parent  =  idx.head.writing()  =  L; // 将splitkey 提升为父结点
                 if  ( split_debug )
                     out ()  <<   "     we were root, making new root: "   <<  hex  <<  parent.getOfs()  <<  dec  <<  endl;
                rLoc.btree() -> parent.writing()  =  parent;
            }
             else  {
                 //  set this before calling _insert - if it splits it will do fixParent() logic and change the value.
                rLoc.btree() -> parent.writing()  =  parent;
                 if  ( split_debug )
                     out ()  <<   "     promoting splitkey key  "   <<  splitkey.key.toString()  <<  endl;
                 // 提升splitkey键，它的左子结点 thisLoc， 右子点rLoc
                parent.btree() -> _insert(parent, splitkey.recordLoc, splitkey.key, order,  /* dupsallowed */ true , thisLoc, rLoc, idx);
            }
        }

         int  newpos  =  keypos;
         //  打包压缩数据(pack,移除无用数据)，以提供更多空间
        truncateTo(split, order, newpos);   //  note this may trash splitkey.key.  thus we had to promote it before finishing up here.

         //  add our new key, there is room now
        {
             if  ( keypos  <=  split ) { // 如果还有空间存储新键
                 if  ( split_debug )
                     out ()  <<   "   keypos<split, insertHere() the new key "   <<  endl;
                insertHere(thisLoc, newpos, recordLoc, key, order, lchild, rchild, idx); // 再次向当前bucket中添加记录
            }
             else  { // 如压缩之后依旧无可用空间，则向新创建的bucket中添加节点
                 int  kp  =  keypos - split - 1 ;
                assert(kp >= 0 );
                rLoc.btree() -> insertHere(rLoc, kp, recordLoc, key, order, lchild, rchild, idx);
            }
        }

         if  ( split_debug )
             out ()  <<   "      split end  "   <<  hex  <<  thisLoc.getOfs()  <<  dec  <<  endl;
    }

    好了，今天的内容到这里就告一段落了，在接下来的文章中，将会介绍客户端发起Delete操作时，Mongodb的执行流程和相应实现部分。

    原文链接:http://www.cnblogs.com/daizhj/archive/2011/03/30/1999699.html