devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

mongodb源码分析(二)_继续前进看看dbquery,上一篇文章提到这里的new dbquery对象的创建发生在:

作者：羊村懒王 | 2024-02-25 12:22:48

赞

踩

继续前进看看dbquery,上一篇文章提到这里的new dbquery对象的创建发生在:

mongodb源码分析(四)查询1之mongo的查询请求

   在之前的2篇文章中分别分析了mongod和mongo的启动流程，下面开始将分析mongodb的查询，由于查询部分流程比较长，将分成mongo端的请求，mongod端的数据库的加载，mongod query的选取，mongod文档的匹配与数据的响应几部分来分析。

         首先进入mongo的查询请求部分.mongo的查询请求部分归纳起来很简单就是将请求分装成一个Message结构,然后将其发送到服务端,等待服务端的相应数据,取得数据最后显示结果.下面来看具体流程分析吧.

   当我们点击db.coll.find({x:1})时按照上一篇文章的讲解，我们首先来到了mongo/shell/dbshell.cpp

[cpp]  view plain copy
  1. if ( ! wascmd ) {  
  2.     try {  
  3.         if ( scope->exec( code.c_str() , "(shell)" , false , true , false ) )//执行相应的javascript代码  
  4.             scope->exec( "shellPrintHelper( __lastres__ );" , "(shell2)" , true , true , false );  
  5.     }  
  6.     catch ( std::exception& e ) {  
  7.         cout << "error:" << e.what() << endl;  
  8.     }  
  9. }  
下面进入javascript代码,其在mongo/shell/collection.js.

[javascript]  view plain copy
  1.     //这里因为我们只设置了query,所以其它选项都是空的，this.getQueryOptions()目前只有一个SlaveOK的option，在replset模式下是不能查询secondary服务器的，需要调用rs.SlaveOK()之后才能对secondary进行查询，其执行SlaveOK后每次查询时都会添加一个QueryOption.  
  2. DBCollection.prototype.find = function (query, fields, limit, skip, batchSize, options) {  
  3.     return new DBQuery( this._mongo , this._db , this ,  
  4.                         this._fullName , this._massageObject( query ) , fields , limit , skip , batchSize , options || this.getQueryOptions() );  
  5. }  
继续前进看看DBQuery,上一篇文章提到这里的new DBQuery对象的创建发生在:

[cpp]  view plain copy
  1. JSBool dbquery_constructor( JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval ) {  
  2.     try {  
  3.         smuassert( cx ,  "DDQuery needs at least 4 args" , argc >= 4 );  
  4. n style="white-space:pre">  </span>    //整个代码都是创建一个DBQuery对象，并未进行任何的查询请求动作  
  5.         Convertor c(cx);  
  6.         c.setProperty( obj , "_mongo" , argv[0] );  
  7.         c.setProperty( obj , "_db" , argv[1] );  
  8.         c.setProperty( obj , "_collection" , argv[2] );  
  9.         c.setProperty( obj , "_ns" , argv[3] );  
  10.   
  11.         if ( argc > 4 && JSVAL_IS_OBJECT( argv[4] ) )  
  12.             c.setProperty( obj , "_query" , argv[4] );  
  13.         else {  
  14.             JSObject * temp = JS_NewObject( cx , 0 , 0 , 0 );  
  15.             CHECKNEWOBJECT( temp, cx, "dbquery_constructor" );  
  16.             c.setProperty( obj , "_query" , OBJECT_TO_JSVAL( temp ) );  
  17.         }  
  18.   
  19.         if ( argc > 5 && JSVAL_IS_OBJECT( argv[5] ) )  
  20.             c.setProperty( obj , "_fields" , argv[5] );  
  21.         else  
  22.             c.setProperty( obj , "_fields" , JSVAL_NULL );  
  23.   
  24.   
  25.         if ( argc > 6 && JSVAL_IS_NUMBER( argv[6] ) )  
  26.             c.setProperty( obj , "_limit" , argv[6] );  
  27.         else  
  28.             c.setProperty( obj , "_limit" , JSVAL_ZERO );  
  29.   
  30.         if ( argc > 7 && JSVAL_IS_NUMBER( argv[7] ) )  
  31.             c.setProperty( obj , "_skip" , argv[7] );  
  32.         else  
  33.             c.setProperty( obj , "_skip" , JSVAL_ZERO );  
  34.   
  35.         if ( argc > 8 && JSVAL_IS_NUMBER( argv[8] ) )  
  36.             c.setProperty( obj , "_batchSize" , argv[8] );  
  37.         else  
  38.             c.setProperty( obj , "_batchSize" , JSVAL_ZERO );  
  39.   
  40.         if ( argc > 9 && JSVAL_IS_NUMBER( argv[9] ) )  
  41.             c.setProperty( obj , "_options" , argv[9] );  
  42.         else  
  43.             c.setProperty( obj , "_options" , JSVAL_ZERO );  
  44.   
  45.         c.setProperty( obj , "_cursor" , JSVAL_NULL );  
  46.         c.setProperty( obj , "_numReturned" , JSVAL_ZERO );  
  47.         c.setProperty( obj , "_special" , JSVAL_FALSE );  
  48.     }  
  49.     catch ( const AssertionException& e ) {  
  50.         if ( ! JS_IsExceptionPending( cx ) ) {  
  51.             JS_ReportError( cx, e.what() );  
  52.         }  
  53.         return JS_FALSE;  
  54.     }  
  55.     catch ( const std::exception& e ) {  
  56.         log() << "unhandled exception: " << e.what() << ", throwing Fatal Assertion" << endl;  
  57.         fassertFailed( 16323 );  
  58.     }  
  59.     return JS_TRUE;  
  60. }  
可以看到上面只有DBQuery对象的构建动作,并没有真正的查询请求，那么查询请求去哪里了呢?回到

[cpp]  view plain copy
  1. try {  
  2.     if ( scope->exec( code.c_str() , "(shell)" , false , true , false ) )//执行相应的javascript代码  
  3.         scope->exec( "shellPrintHelper( __lastres__ );" , "(shell2)" , true , true , false );  
  4. }  

继续分析shellPrintHelper函数，这里__lastres__是什么，搜索整个source insight工程发现mongo/scripting/engine_spidermonkey.cpp中:
[cpp]  view plain copy
  1. bool exec( const StringData& code,const string& name = "(anon)",bool printResult = false,bool reportError = true, bool assertOnError = true,int timeoutMs = 0 ) {  
  2.     JSBool worked = JS_EvaluateScript( _context,  
  3.                                        _global,  
  4.                                        code.data(),  
  5.                                        code.size(),  
  6.                                        name.c_str(),  
  7.                                        1,  
  8.                                        &ret );  
  9.     if ( worked )  
  10.         _convertor->setProperty( _global , "__lastres__" , ret );  
  11. }  
原来__lastres__就是上一条执行语句的结果也就是这里的DBQuery对象.继续分析shellPrintHelper函数(mongo/util/util.js)
[javascript]  view plain copy
  1. shellPrintHelper = function (x) {  
  2.     if (typeof (x) == "undefined") {  
  3.         // Make sure that we have a db var before we use it  
  4.         // TODO: This implicit calling of GLE can cause subtle, hard to track issues - remove?  
  5.         if (__callLastError && typeof( db ) != "undefined" && db.getMongo ) {  
  6.             __callLastError = false;  
  7.             // explicit w:1 so that replset getLastErrorDefaults aren't used here which would be bad.  
  8.             var err = db.getLastError(1);  
  9.             if (err != null) {  
  10.                 print(err);  
  11.             }  
  12.         }  
  13.         return;  
  14.     }  
  15.   
  16.     if (x == __magicNoPrint)  
  17.         return;  
  18.   
  19.     if (x == null) {  
  20.         print("null");  
  21.         return;  
  22.     }  
  23.   
  24.     if (typeof x != "object")  
  25.         return print(x);  
  26.   
  27.     var p = x.shellPrint;//我们这里是DBQuery对象，所以执行到这里，来到了DBQuery.shellPrint函数  
  28.     if (typeof p == "function")  
  29.         return x.shellPrint();  
  30.   
  31.     var p = x.tojson;  
  32.     if (typeof p == "function")  
  33.         print(x.tojson());  
  34.     else  
  35.         print(tojson(x));  
  36. }  
[javascript]  view plain copy
  1. DBQuery.prototype.shellPrint = function(){//(mongo/util/query.js)  
  2.     try {  
  3.         var start = new Date().getTime();  
  4.         var n = 0;//还有查询结果并且输出数目小于shellBatchSize,循环打印结果  
  5.         while ( this.hasNext() && n < DBQuery.shellBatchSize ){//这里shellBatchSize定义为20  
  6.             var s = this._prettyShell ? tojson( this.next() ) : tojson( this.next() , "" , true );  
  7.             print( s );//调用native函数native_print打印结果  
  8.             n++;  
  9.         }  
  10.         if (typeof _verboseShell !== 'undefined' && _verboseShell) {  
  11.             var time = new Date().getTime() - start;  
  12.             print("Fetched " + n + " record(s) in " + time + "ms");  
  13.         }  
  14.          if ( this.hasNext() ){  
  15.             print( "Type \"it\" for more" );  
  16.             ___it___  = this;  
  17.         }  
  18.         else {  
  19.             ___it___  = null;  
  20.         }  
  21.    }  
  22.     catch ( e ){  
  23.         print( e );  
  24.     }  
  25.       
  26. }  
继续看看hasNext函数和next函数:
[javascript]  view plain copy
  1. DBQuery.prototype.hasNext = function(){  
  2.     this._exec();  
  3.   
  4.     if ( this._limit > 0 && this._cursorSeen >= this._limit )//超过了限制返回false，将不会再输出结果  
  5.         return false;  
  6.     var o = this._cursor.hasNext();  
  7.     return o;  
  8. }  
  9.   
  10. DBQuery.prototype.next = function(){  
  11.     this._exec();  
  12.       
  13.     var o = this._cursor.hasNext();  
  14.     if ( o )  
  15.         this._cursorSeen++;  
  16.     else  
  17.         throw "error hasNext: " + o;  
  18.       
  19.     var ret = this._cursor.next();  
  20.     if ( ret.$err && this._numReturned == 0 && ! this.hasNext() )  
  21.         throw "error: " + tojson( ret );  
  22.   
  23.     this._numReturned++;  
  24.     return ret;  
  25. }  
继续前进到_exec函数:
[javascript]  view plain copy
  1. DBQuery.prototype._exec = function(){//到这里终于到了this._mongo.find  
  2.     if ( ! this._cursor ){  
  3.         assert.eq( 0 , this._numReturned );  
  4.         this._cursor = this._mongo.find( this._ns , this._query , this._fields , this._limit , this._skip , this._batchSize , this._options );  
  5.         this._cursorSeen = 0;  
  6.     }  
  7.     return this._cursor;  
  8. }  
到这里我们来到了this._mongo.find,这里_mongo是一个Mongo对象，在上一篇文章中我们了解到find函数是本地函数mongo_find.继续分析
mongo_find(mongo/scripting/sm_db.cpp).这里删除了部分错误处理代码.
[cpp]  view plain copy
  1. JSBool mongo_find(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) {  
  2.         shared_ptr< DBClientWithCommands > * connHolder = (shared_ptr< DBClientWithCommands >*)JS_GetPrivate( cx , obj );  
  3.         smuassert( cx ,  "no connection!" , connHolder && connHolder->get() );  
  4.         DBClientWithCommands *conn = connHolder->get();  
  5.         Convertor c( cx );  
  6.         string ns = c.toString( argv[0] );  
  7.         BSONObj q = c.toObject( argv[1] );  
  8.         BSONObj f = c.toObject( argv[2] );  
  9.   
  10.         int nToReturn = (int) c.toNumber( argv[3] );  
  11.         int nToSkip = (int) c.toNumber( argv[4] );  
  12.         int batchSize = (int) c.toNumber( argv[5] );  
  13.         int options = (int)c.toNumber( argv[6] );//上面一篇文章我们分析到这里的conn其实是由ConnectionString::connect函数返回的，其返回的对象指针可能是:DBClientConnection对应Master,也就是只设置了一个地址，DBClientReplicaSet对应pair或者set模式,SyncClusterConnection对应sync模式，继续分析流程我们选择最简单的Master模式,只有一个地址的服务端  
  14.         auto_ptr<DBClientCursor> cursor = conn->query( ns , q , nToReturn , nToSkip , f.nFields() ? &f : 0  , options , batchSize );  
  15.         if ( ! cursor.get() ) {  
  16.             log() << "query failed : " << ns << " " << q << " to: " << conn->toString() << endl;  
  17.             JS_ReportError( cx , "error doing query: failed" );  
  18.             return JS_FALSE;  
  19.         }  
  20.         JSObject * mycursor = JS_NewObject( cx , &internal_cursor_class , 0 , 0 );  
  21.         CHECKNEWOBJECT( mycursor, cx, "internal_cursor_class" );  
  22.         verify( JS_SetPrivate( cx , mycursor , new CursorHolder( cursor, *connHolder ) ) );  
  23.         *rval = OBJECT_TO_JSVAL( mycursor );  
  24.     return JS_TRUE;  
  25. }  
那么我们继续前进来到DBClientConnection::query函数，该函数只是简单调用了DBClientBase::query函数.
[cpp]  view plain copy
  1. auto_ptr<DBClientCursor> DBClientBase::query(const string &ns, Query query, int nToReturn,  
  2.         int nToSkip, const BSONObj *fieldsToReturn, int queryOptions , int batchSize ) {  
  3.     auto_ptr<DBClientCursor> c( new DBClientCursor( this,//根据传入的参数创建一个DBClientCursor对象  
  4.                                 ns, query.obj, nToReturn, nToSkip,  
  5.                                 fieldsToReturn, queryOptions , batchSize ) );  
  6.     if ( c->init() )//创建Message并向服务端发送查询请求  
  7.         return c;  
  8.     return auto_ptr< DBClientCursor >( 0 );  
  9. }  
[cpp]  view plain copy
  1. bool DBClientCursor::init() {  
  2.     Message toSend;  
  3.     _assembleInit( toSend );//构建将要发送的查询请求这是一个Message,具体来说Message负责发送数据,具体的数据是在MsgData中  
  4.     verify( _client );  
  5.     if ( !_client->call( toSend, *batch.m, false, &_originalHost ) ) {//实际的发送数据,同时这里发送了数据后会调用recv接收数据  
  6.         // log msg temp?                                              //接收的数据同样是MsgData，同样由Message来管理  
  7.         log() << "DBClientCursor::init call() failed" << endl;  
  8.         return false;  
  9.     }  
  10.     if ( batch.m->empty() ) {  
  11.         // log msg temp?  
  12.         log() << "DBClientCursor::init message from call() was empty" << endl;  
  13.         return false;  
  14.     }  
  15.     dataReceived();//根据上面的batch.m收到的数据得出查询是否成功成功则设置cursorId,下一次请求时operation就变动为dbGetmore了.  
  16.     return true;   //查询错误则抛出异常  
  17. }  
_assembleInit是创建一个message结构，若是第一次请求那么请求操作为dbQuery,若不是则请求操作为dbGetmore.来看看MsgData的具体结构吧.

回到mongo_find函数.
[cpp]  view plain copy
  1. auto_ptr<DBClientCursor> cursor = conn->query( ns , q , nToReturn , nToSkip , f.nFields() ? &f : 0  , options , batchSize );  
  2. if ( ! cursor.get() ) {//这里得到了cursor  
  3.     log() << "query failed : " << ns << " " << q << " to: " << conn->toString() << endl;  
  4.     JS_ReportError( cx , "error doing query: failed" );  
  5.     return JS_FALSE;  
  6. }  
  7. JSObject * mycursor = JS_NewObject( cx , &internal_cursor_class , 0 , 0 );//将cursor封装成一个javascript对象,javascript就能  
  8. CHECKNEWOBJECT( mycursor, cx, "internal_cursor_class" );//使用游标了  
  9. verify( JS_SetPrivate( cx , mycursor , new CursorHolder( cursor, *connHolder ) ) );  
我们回到javascript部分的打印请求.
[javascript]  view plain copy
  1. DBQuery.prototype.hasNext = function(){  
  2.     this._exec();  
  3.   
  4.     if ( this._limit > 0 && this._cursorSeen >= this._limit )  
  5.         return false;  
  6.     var o = this._cursor.hasNext();//这里的cursor对应于上面的C++对象cursor,其hasNext函数对应的native函数为internal_cursor_hasNext,  
  7.     return o;                      //这是在mongo启动时初始化javascript环境时绑定的  
  8. }  
继续看到了internal_cursor_hasNext:
[cpp]  view plain copy
  1. JSBool internal_cursor_hasNext(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) {  
  2.     try {  
  3.         DBClientCursor *cursor = getCursor( cx, obj );  
  4.         *rval = cursor->more() ? JSVAL_TRUE : JSVAL_FALSE;//这里返回的就是是否还有数据,如果本地没有查询数据了,那么其会再构建一个  
  5.     }                                                     //dbGetmore的请求向服务器请求更多数据,还是没有则返回false,表示没有数据了  
  6.     catch ( const AssertionException& e ) {  
  7.         if ( ! JS_IsExceptionPending( cx ) ) {  
  8.             JS_ReportError( cx, e.what() );  
  9.         }  
  10.         return JS_FALSE;  
  11.     }  
  12.     catch ( const std::exception& e ) {  
  13.         log() << "unhandled exception: " << e.what() << ", throwing Fatal Assertion" << endl;  
  14.         fassertFailed( 16290 );  
  15.     }  
  16.     return JS_TRUE;  
  17. }  
最后javascript部分打印数据:
[javascript]  view plain copy
  1. DBQuery.prototype.shellPrint = function(){  
  2.     try {  
  3.         var start = new Date().getTime();  
  4.         var n = 0;  
  5.         while ( this.hasNext() && n < DBQuery.shellBatchSize ){//前面分析这里hasNext对应C++函数internal_cursor_hasNext,next对应  
  6.             var s = this._prettyShell ? tojson( this.next() ) : tojson( this.next() , "" , true );//internal_cursor_next,怎么得到的数据不再分析  
  7.             print( s );//调用native_print打印结果  
  8.             n++;  
  9.         }  

下面来看看类似这种形式的命令:db.coll.find().count(), db.coll.find().showDiskLoc().
[javascript]  view plain copy
  1. DBQuery.prototype.sort = function( sortBy ){//可以看到,这里只是在查询时增加了相应的查询请求而已  
  2.     return this._addSpecial( "orderby" , sortBy );  
  3. }  
  4.   
  5. DBQuery.prototype.hint = function( hint ){  
  6.     return this._addSpecial( "$hint" , hint );  
  7. }  
  8.   
  9. DBQuery.prototype.min = function( min ) {  
  10.     return this._addSpecial( "$min" , min );  
  11. }  
  12.   
  13. DBQuery.prototype.max = function( max ) {  
  14.     return this._addSpecial( "$max" , max );  
  15. }  
  16.   
  17. DBQuery.prototype.showDiskLoc = function() {  
  18.     return this._addSpecial( "$showDiskLoc" , true);  
  19. }  
[javascript]  view plain copy
  1. DBQuery.prototype.count = function( applySkipLimit ){//而这里count这种是变更了查询的,这里是向服务器发送了一个count命令,执行的并不是  
  2.     var cmd = { count: this._collection.getName() };//查询请求  
  3.     if ( this._query ){  
  4.         if ( this._special )  
  5.             cmd.query = this._query.query;  
  6.         else   
  7.             cmd.query = this._query;  
  8.     }  
  9.     cmd.fields = this._fields || {};  
  10.   
  11.     if ( applySkipLimit ){  
  12.         if ( this._limit )  
  13.             cmd.limit = this._limit;  
  14.         if ( this._skip )  
  15.             cmd.skip = this._skip;  
  16.     }  
  17.       
  18.     var res = this._db.runCommand( cmd );  
  19.     if( res && res.n != null ) return res.n;  
  20.     throw "count failed: " + tojson( res );  
  21. }  
  22.   
  23. DBQuery.prototype.size = function(){  
  24.     return this.count( true );  
  25. }  

        总结,本文分析了mongodb自带的mongo客户端发起的查询请求以及结果的打印过程，
总体来说流程很简单,唯一令人感到麻烦的就是代码的执行流程在javascript和C++中来回的切换,
需要注意的就是对于mongo的查询请求的格式MsgData.

作者:yhjj0108,杨浩

 

mongodb源码分析(五)查询2之mongod的数据库加载


 上一篇文章分析到了客户端查询请求的发送，接着分析服务端的处理动作，分析从服务端响应开始到数据库

正确加载止,主要流程为数据库的读入过程与用户的认证.

        mongod服务对于客户端请求的处理在mongo/db/db.cpp MyMessageHandler::process中，其中调用了

函数assembleResponse完成请求响应,我们就从这个函数开始入手分析,代码很长,删除一些支流或者不相关的代码.

[cpp]  view plain copy
  1. void assembleResponse( Message &m, DbResponse &dbresponse, const HostAndPort& remote ) {  
  2.     if ( op == dbQuery ) {  
  3.         if( strstr(ns, ".$cmd") ) {  
  4.             isCommand = true;  
  5.             opwrite(m);//写入诊断用的log,默认loglevel为0,未开启,需要开启启动时加入--diaglog x,0 = off; 1 = writes, 2 = reads, 3 = both  
  6.             if( strstr(ns, ".$cmd.sys.") ) {//7 = log a few reads, and all writes.  
  7.                 if( strstr(ns, "$cmd.sys.inprog") ) {  
  8.                     inProgCmd(m, dbresponse);//查看当前进度的命令  
  9.                     return;  
  10.                 }  
  11.                 if( strstr(ns, "$cmd.sys.killop") ) {  
  12.                     killOp(m, dbresponse);//终止当前操作  
  13.                     return;  
  14.                 }  
  15.                 if( strstr(ns, "$cmd.sys.unlock") ) {  
  16.                     unlockFsync(ns, m, dbresponse);  
  17.                     return;  
  18.                 }  
  19.             }  
  20.         }  
  21.         else {  
  22.             opread(m);  
  23.         }  
  24.     }  
  25.     else if( op == dbGetMore ) {  
  26.         opread(m);  
  27.     }  
  28.     else {  
  29.         opwrite(m);  
  30.     }  
  31.     long long logThreshold = cmdLine.slowMS;//启动的时候设置的参数默认是100ms,当操作超过了这个时间且启动时设置--profile为1或者2  
  32.     bool shouldLog = logLevel >= 1;//时mongodb将记录这次慢操作,1为只记录慢操作,即操作时间大于了设置的slowMS,2表示记录所有操作  
  33.     if ( op == dbQuery ) {         //可通过--slowms设置slowMS  
  34.         if ( handlePossibleShardedMessage( m , &dbresponse ) )//这里和shard有关,以后会的文章会讲到  
  35.             return;  
  36.         receivedQuery(c , dbresponse, m );//真正的查询入口  
  37.     }  
  38.     else if ( op == dbGetMore ) {//已经查询了数据,这里只是执行得到更多数据的入口  
  39.         if ( ! receivedGetMore(dbresponse, m, currentOp) )  
  40.             shouldLog = true;  
  41.     }  
  42.             if ( op == dbKillCursors ) {  
  43.                 currentOp.ensureStarted();  
  44.                 logThreshold = 10;  
  45.                 receivedKillCursors(m);  
  46.             }  
  47.             else if ( op == dbInsert ) {//插入操作入口  
  48.                 receivedInsert(m, currentOp);  
  49.             }  
  50.             else if ( op == dbUpdate ) {//更新操作入口  
  51.                 receivedUpdate(m, currentOp);  
  52.             }  
  53.             else if ( op == dbDelete ) {//删除操作入口  
  54.                 receivedDelete(m, currentOp);  
  55.             }  
  56.     if ( currentOp.shouldDBProfile( debug.executionTime ) ) {//该操作将被记录,原因可能有二:一,启动时设置--profile 2,则所有操作将被  
  57.         // performance profiling is on                    //记录.二,启动时设置--profile 1,且操作时间超过了默认的slowMs,那么操作将被            else {//这个地方if部分被删除了,就是在不能获取锁的状况下不记录该操作的代码  
  58.             Lock::DBWrite lk( currentOp.getNS() );//记录具体记录操作,就是在xxx.system.profile集合中插入该操作的具体记录  
  59.             if ( dbHolder()._isLoaded( nsToDatabase( currentOp.getNS() ) , dbpath ) ) {  
  60.                 Client::Context cx( currentOp.getNS(), dbpath, false );  
  61.                 profile(c , currentOp );  
  62.             }  
  63.         }  
  64.     }  

前进到receivedQuery,其解析了接收到的数据,然后调用runQuery负责处理查询,然后出来runQuery抛出的异常,直接进入runQuery.

[cpp]  view plain copy
  1. string runQuery(Message& m, QueryMessage& q, CurOp& curop, Message &result) {          
  2. red_ptr<ParsedQuery> pq_shared( new ParsedQuery(q) );  
  3.     if ( pq.couldBeCommand() ) {//这里表明这是一个命令,关于mongodb的命令的讲解这里有一篇文章,我就不再分析了.  
  4.         BSONObjBuilder cmdResBuf;//<a href="http://www.cnblogs.com/daizhj/archive/2011/04/29/mongos_command_source_code.html">http://www.cnblogs.com/daizhj/archive/2011/04/29/mongos_command_source_code.html</a>  
  5.         if ( runCommands(ns, jsobj, curop, bb, cmdResBuf, false, queryOptions) ){}  
  6.   
  7.     bool explain = pq.isExplain();//这里的explain来自这里db.coll.find().explain(),若使用了.explain()则为true,否则false  
  8.     BSONObj order = pq.getOrder();  
  9.     BSONObj query = pq.getFilter();  
  10.     // Run a simple id query.  
  11.     if ( ! (explain || pq.showDiskLoc()) && isSimpleIdQuery( query ) && !pq.hasOption( QueryOption_CursorTailable ) ) {  
  12.         if ( queryIdHack( ns, query, pq, curop, result ) ) {//id查询的优化  
  13.             return "";  
  14.         }  
  15.     }  
  16.     bool hasRetried = false;  
  17.     while ( 1 ) {//这里的ReadContext这这篇文章的主角,其内部在第一次锁数据库时完成了数据库的加载动作  
  18.             Client::ReadContext ctx( ns , dbpath ); // read locks  
  19.             replVerifyReadsOk(&pq);//还记得replset模式中无法查询secondary服务器吗,就是在这里限制的  
  20.             BSONObj oldPlan;  
  21.             if ( ! hasRetried && explain && ! pq.hasIndexSpecifier() ) {  
  22.                 scoped_ptr<MultiPlanScanner> mps( MultiPlanScanner::make( ns, query, order ) );  
  23.                 oldPlan = mps->cachedPlanExplainSummary();  
  24.             }//这里才是真正的查询,其内部很复杂,下一篇文章将讲到  
  25.             return queryWithQueryOptimizer( queryOptions, ns, jsobj, curop, query, order,  
  26.                                             pq_shared, oldPlan, shardingVersionAtStart,   
  27.                                             pgfs, npfe, result );  
  28.         }  
  29.     }  
  30. }  
[cpp]  view plain copy
  1. Client::ReadContext::ReadContext(const string& ns, string path, bool doauth ) {  
  2.         {  
  3.             lk.reset( new Lock::DBRead(ns) );//数据库锁,这里mongodb的锁机制本文将不会涉及到,感兴趣的自己分析  
  4.             Database *db = dbHolder().get(ns, path);  
  5.             if( db ) {//第一次加载时显然为空  
  6.                 c.reset( new Context(path, ns, db, doauth) );  
  7.                 return;  
  8.             }  
  9.         }  
  10.         if( Lock::isW() ) { //全局的写锁  
  11.             // write locked already  
  12.                 DEV RARELY log() << "write locked on ReadContext construction " << ns << endl;  
  13.                 c.reset( new Context(ns, path, doauth) );  
  14.             }  
  15.         else if( !Lock::nested() ) {   
  16.             lk.reset(0);  
  17.             {  
  18.                 Lock::GlobalWrite w;//加入全局的写锁,这里是真正的数据库加载地点  
  19.                 Context c(ns, path, doauth);  
  20.             }  
  21.             // db could be closed at this interim point -- that is ok, we will throw, and don't mind throwing.  
  22.             lk.reset( new Lock::DBRead(ns) );  
  23.             c.reset( new Context(ns, path, doauth) );  
  24.         }  
  25.     }  
[cpp]  view plain copy
  1. Client::Context::Context(const string& ns, string path , bool doauth, bool doVersion ) :  
  2.     _client( currentClient.get() ),   
  3.     _oldContext( _client->_context ),  
  4.     _path( path ),   
  5.     _justCreated(false), // set for real in finishInit  
  6.     _doVersion(doVersion),  
  7.     _ns( ns ),   
  8.     _db(0)   
  9. {  
  10.     _finishInit( doauth );  
  11. }  
继续看_finishInit函数:

[cpp]  view plain copy
  1. void Client::Context::_finishInit( bool doauth ) {  
  2.     _db = dbHolderUnchecked().getOrCreate( _ns , _path , _justCreated );//读取或者创建数据库  
  3.     checkNsAccess( doauth, writeLocked ? 1 : 0 );//认证检查  
  4. }  
[cpp]  view plain copy
  1. Database* DatabaseHolder::getOrCreate( const string& ns , const string& path , bool& justCreated ) {  
  2.     string dbname = _todb( ns );//将test.coll这种类型的字符串转换为test  
  3.     {  
  4.         SimpleMutex::scoped_lock lk(_m);  
  5.         Lock::assertAtLeastReadLocked(ns);  
  6.         DBs& m = _paths[path];//在配置的路径中找到已经加载的数据库,直接返回  
  7.         {  
  8.             DBs::iterator i = m.find(dbname);   
  9.             if( i != m.end() ) {  
  10.                 justCreated = false;  
  11.                 return i->second;  
  12.             }  
  13.         }  
  14.     Database *db = new Database( dbname.c_str() , justCreated , path );//实际的数据读取  
  15.     {  
  16.         SimpleMutex::scoped_lock lk(_m);//数据库加载完成后按照路径数据库记录  
  17.         DBs& m = _paths[path];  
  18.         verify( m[dbname] == 0 );  
  19.         m[dbname] = db;  
  20.         _size++;  
  21.     }  
  22.     return db;  
  23. }  
[cpp]  view plain copy
  1. Database::Database(const char *nm, bool& newDb, const string& _path )  
  2.     : name(nm), path(_path), namespaceIndex( path, name ),  
  3.       profileName(name + ".system.profile")  
  4. {  
  5.     try {  
  6.         newDb = namespaceIndex.exists();//查看xxx.ns文件是否存储,存在表示数据库已经创建  
  7.         // If already exists, open.  Otherwise behave as if empty until  
  8.         // there's a write, then open.  
  9.         if (!newDb) {  
  10.             namespaceIndex.init();//加载具体的xxx.ns文件  
  11.             if( _openAllFiles )  
  12.                 openAllFiles();//加载所有的数据文件xxx.0,xxx.1,xxx.2这种类型的文件  
  13.         }  
  14.         magic = 781231;  
  15. }  
继续看namespaceIndex::init函数,若其未初始化则调用_init初始化,初始化了则什么也不做,直接去到namespaceIndex::_init

[cpp]  view plain copy
  1. NOINLINE_DECL void NamespaceIndex::_init() {  
  2.     unsigned long long len = 0;  
  3.     boost::filesystem::path nsPath = path();//xxx.ns  
  4.     string pathString = nsPath.string();  
  5.     void *p = 0;  
  6.     if( boost::filesystem::exists(nsPath) ) {//如果存在该文件,则使用内存映射文件map该文件  
  7.         if( f.open(pathString, true) ) {//这里f为MongoMMF对象  
  8.             len = f.length();  
  9.             if ( len % (1024*1024) != 0 ) {  
  10.                 log() << "bad .ns file: " << pathString << endl;  
  11.                 uassert( 10079 ,  "bad .ns file length, cannot open database", len % (1024*1024) == 0 );  
  12.             }  
  13.             p = f.getView();//这里得到map的文件的指针  
  14.         }  
  15.     }  
  16.     else {  
  17.         // use lenForNewNsFiles, we are making a new database  
  18.         massert( 10343, "bad lenForNewNsFiles", lenForNewNsFiles >= 1024*1024 );  
  19.         maybeMkdir();  
  20.         unsigned long long l = lenForNewNsFiles;//创建具体的ns文件,默认大小是16M,可以用--nssize 来设置大小,MB为单位,只对新创建的数据库  
  21.         if( f.create(pathString, l, true) ) {   //起作用  
  22.             getDur().createdFile(pathString, l); // always a new file  
  23.             len = l;  
  24.             verify( len == lenForNewNsFiles );  
  25.             p = f.getView();  
  26.         }  
  27.     }  
  28.     verify( len <= 0x7fffffff );  
  29.     ht = new HashTable<Namespace,NamespaceDetails>(p, (int) len, "namespace index");  
  30.     if( checkNsFilesOnLoad )  
  31.         ht->iterAll(namespaceOnLoadCallback);  
  32. }  
继续看MongoMMF::open流程:

[cpp]  view plain copy
  1. bool MongoMMF::open(string fname, bool sequentialHint) {  
  2.     LOG(3) << "mmf open " << fname << endl;  
  3.     setPath(fname);  
  4.     _view_write = mapWithOptions(fname.c_str(), sequentialHint ? SEQUENTIAL : 0);//这里是真正的映射,  
  5.     return finishOpening();  
  6. }  
[cpp]  view plain copy
  1. bool MongoMMF::finishOpening() {  
  2.     if( _view_write ) {  
  3.         if( cmdLine.dur ) {//开启了journal功能后创建一个私有的map,这个日志功能我将以后专门写一篇文章分析.  
  4.             _view_private = createPrivateMap();  
  5.             if( _view_private == 0 ) {  
  6.                 msgasserted(13636, str::stream() << "file " << filename() << " open/create failed in createPrivateMap (look in log for more information)");  
  7.             }  
  8.             privateViews.add(_view_private, this); // note that testIntent builds use this, even though it points to view_write then...  
  9.         }  
  10.         else {  
  11.             _view_private = _view_write;  
  12.         }  
  13.         return true;  
  14.     }  
  15.     return false;  
  16. }  
回到namespaceIndex::_init函数:

[cpp]  view plain copy
  1. ht = new HashTable<Namespace,NamespaceDetails>(p, (int) len, "namespace index");  
这里有必要关注下NamespaceDetails结构,每一个集合对应于一个NamespaceDetails结构,该结构作用如下(来自NamespaceDetails结构的上的描述)

NamespaceDetails : this is the "header" for a collection that has all its details.
       It's in the .ns file and this is a memory mapped region (thus the pack pragma above).

[cpp]  view plain copy
  1. class NamespaceDetails {  
  2. public:  
  3.     enum { NIndexesMax = 64, NIndexesExtra = 30, NIndexesBase  = 10 };  
  4.     /*-------- data fields, as present on disk : */  
  5.     DiskLoc firstExtent;//记录第一个extent,在分析数据的插入时会具体讨论mongodb的存储  
  6.     DiskLoc lastExtent;//记录的最后一个extent  
  7.     /* NOTE: capped collections v1 override the meaning of deletedList. 
  8.              deletedList[0] points to a list of free records (DeletedRecord's) for all extents in 
  9.              the capped namespace. 
  10.              deletedList[1] points to the last record in the prev extent.  When the "current extent" 
  11.              changes, this value is updated.  !deletedList[1].isValid() when this value is not 
  12.              yet computed. 
  13.     */  
  14.     DiskLoc deletedList[Buckets];  
  15.     // ofs 168 (8 byte aligned)  
  16.     struct Stats {  
  17.         // datasize and nrecords MUST Be adjacent code assumes!  
  18.         long long datasize; // this includes padding, but not record headers  
  19.         long long nrecords;  
  20.     } stats;  
  21.     int lastExtentSize;  
  22.     int nIndexes;  
  23. private:  
  24.     // ofs 192  
  25.     IndexDetails _indexes[NIndexesBase];//10个索引保存到这里,若1个集合索引超过10其它的索引以extra的形式存在,extra地址保存在下面的  
  26.     // ofs 352 (16 byte aligned)        //extraOffset处  
  27.     int _isCapped;                         // there is wasted space here if I'm right (ERH)  
  28.     int _maxDocsInCapped;                  // max # of objects for a capped table.  TODO: should this be 64 bit?  
  29.     double _paddingFactor;                 // 1.0 = no padding.  
  30.     // ofs 386 (16)  
  31.     int _systemFlags; // things that the system sets/cares about  
  32. public:  
  33.     DiskLoc capExtent;  
  34.     DiskLoc capFirstNewRecord;  
  35.     unsigned short dataFileVersion;       // NamespaceDetails version.  So we can do backward compatibility in the future. See filever.h  
  36.     unsigned short indexFileVersion;  
  37.     unsigned long long multiKeyIndexBits;  
  38. private:  
  39.     // ofs 400 (16)  
  40.     unsigned long long reservedA;  
  41.     long long extraOffset;                // where the $extra info is located (bytes relative to this)  
  42. public:  
  43.     int indexBuildInProgress;             // 1 if in prog  
  44. private:  
  45.     int _userFlags;  
  46.     char reserved[72];  
  47.     /*-------- end data 496 bytes */  
从这里可以明白ns保存了所有集合的头信息,其中包括了该集合的起始位置，结束位置以及索引所在.

_init函数执行完毕,网上回到Database::Database()函数:

[cpp]  view plain copy
  1. if( _openAllFiles )  
  2.     openAllFiles();//这里映射所有的xx.0,xx.1这种文件,记录映射的文件,映射的方式如同映射xx.ns,在开启了journal时同时保存两份地址.这里不再分析,感兴趣的自己研究吧  
至此数据库的映射工作完成.往上回到Client::Context::_finishInit函数,下面来看看权限的检查函数checkNsAccess,其最终调用了下面的函数,通过认证返回true,

未通过将返回false,返回false,将导致mongod向客户端发送未认证信息,客户端的操作请求失败

[cpp]  view plain copy
  1.     bool AuthenticationInfo::_isAuthorized(const string& dbname, Auth::Level level) const {  
  2.         if ( noauth ) {//启动时可--noauth设置为true,--auth设置为false,默认为false  
  3.             return true;  
  4.         }  
  5.         {  
  6.             scoped_spinlock lk(_lock);  
  7. <span style="white-space:pre">  </span>    //查询dbname这个数据库是否已经得到认证,这里的认证数据是在mongo启动时连接服务端认证通过后保存的  
  8.             if ( _isAuthorizedSingle_inlock( dbname , level ) )  
  9.                 return true;  
  10.   
  11.             if ( _isAuthorizedSingle_inlock( "admin" , level ) )  
  12.                 return true;  
  13.   
  14.             if ( _isAuthorizedSingle_inlock( "local" , level ) )  
  15.                 return true;  
  16.         }  
  17.         return _isAuthorizedSpecialChecks( dbname );//若未通过上面的认证将会查看是否打开了_isLocalHostAndLocalHostIsAuthorizedForAll,也就是该连接是否是来自于本地连接.  
  18.     }  


       本文到这里结束,主要是搞清楚了mongod接收到来自客户端请求后的执行流程到数据库的加载,重要的

是明白ns文件的作用,普通数据文件xx.0,xx.1的映射,下一篇文章我们将继续分析查询请求的处理.


本文链接:http://blog.csdn.net/yhjj0108/article/details/8255968

作者: yhjj0108,杨浩


mongodb源码分析(六)查询3之mongod的cursor的产生

     上一篇文章分析了mongod的数据库加载部分,下面这一篇文章将继续分析mongod cursor的产生,这里cursor

的生成应该是mongodb系统中最复杂的部分.下面先介绍几个关于mongodb的游标概念.


basicCursor: 直接扫描整个collection的游标,可设置初始的扫描位置,扫描为顺序扫描.

ReverseCursor: 反向扫描游标,相对于顺序扫描,这里是反向扫描.

ReverseCappedCursor: cap集合的反向扫描游标.

ForwardCappedCursor: cap集合的顺序扫描游标.

GeoCursorBase:     空间地理索引游标的基类,我并未阅读相关代码,感兴趣的自己研究吧.

BtreeCursor:    mongodb的一般数据索引扫描游标,这个游标完成对于索引的扫描.

MultiCursor:     有待研究.

QueryOptimizerCursor:  经过优化的扫描游标,多plan扫描时或者对于查询中有$or的语句且$or语句其作用时由于

优化查询的游标. 这里将简单描述其流程.

1. 如果是类似这种db.coll.find()的查询则将直接返回一个BasicCursor的游标扫描全表.

2. 如果是简单的id查询如db.coll.find(_id:xxx),且允许_id查询plan的情况下直接查询_id索引,返回一个_id索引

    的BtreeCursor.

3.根据查询整理出查询值的范围,作为优化查询范围的依据,如:db.coll.find({x:{$lt:100,$gt:20}}),那么这里其范围就
   是[20.100],这个范围只有在对应的变量是索引的情况下起作用,如x为其中的一个索引,那么这里的范围将帮助其
   游标BtreeCursor首先直接将查询范围定位到[20,100]的位置,这个工作对于由Btree组织的索引来说很简单.简单
   来说就是优化查询范围.但是若x不是索引那么这里得到的查询范围将是无用的,这里将返回一个BasicCursor的

   游标执行全表扫描.

4.根据得到的所有的查询域的范围比如说x:[10,20],y:[4,6]这种选取查询计划(QueryPlan).查询计划的选取这里举个

    例子,有x,y两个查询域.index有{x:1},{y:1},{x:1,y:1}这几个索引,那么选取计划时发现只有索引{x:1,y:1}完全满足查

    询计划,其是最优的,那么确定选取这个索引为查询索引.返回唯一的QueryPlan,最后生成一个确切的

    BtreeCursor.但是如果没有{x:1,y:1}这个索引怎么办呢?那么剩下两个索引{x:1},{y:1}都部分包含了查询域,他们

    都是有作用的,于是乎生成了两个QueryPlan,一个对应于索引{x:1},一个对应于索引{y:1},于是乎使用

    QueryOptimizerCursor这个cursor管理两个BtreeCursor,每次交替执行两个BtreeCursor的查询,直到一个

    BtreeCursor查询完毕,那么这个plan是所有plan中最优的,将其缓存起来,下一次同样查询时直接选择这个plan作

    为查询的plan.因为两个plan中首先完成扫描的plan查询的次数最少.那么两个plan都查询到的同一条满足查询要

    求的数据怎么办,查询结尾会有一个对于满足要求的document地址的记录,如果一条满足要求的document的地址

    已经在记录中了,就不再记录这个document.

5.$or查询的优化,对于一个$or举例来说明:{$or:[{x:1},{y:2},{z:3,a:4}]}这样的查询请求,这样要当$or中的每一个查

    询域,中至少一个域是可用的索引比如说有索引x,y,a那么这个$or才是有意义的.如果这个$or有意义,那么这里将

    使用QueryOptimizerCursor来处理每一个$or中的查询域,比如说{x:1},然后这里退化到4,plan的选取,$or中的查

    询一个一个的执行.回过头来分析,如果没有索引y,那么对于这个$or的查询因为满足y:2的文档将会被返回,那么

    只能扫描全表,这时即使有索引x,z或者a这种也不能避免全表的扫描,那么这里的$or就变得没有优化的意义了. 

    另外如果查询指定了sort(xxx:1)按照某些域排序或者设定了最大值最小值$or也是无意义的.

6. 查询结束后的排序,当指定了如db.coll.find({x:1,y:2}).sort(z:1),这种需要按照z升序排列的查询时,这种情况就要

    考虑当没有索引z时,那么排序是肯定避免不了的,查询的结果会放到一个map中,map按照z的升序来排序,当排序

    的文档总大小超过了默认热32M最大值时会返回错误,提醒你应该为z域建立索引了.下面来看有索引时的状况.

(1),索引为{x:1},{z:1},如果这里两个索引查询的文档数目一样多,那么优先选择{x:1},因为建立索引时其比较靠前,然

     后还是得排序.

(2)索引{x:1,z:1},{z:1,x:1},由于第一个索引查出来的顺序是按照x的顺序来排列的,那么还是得排序,第二个索引不需

     要排序,但是考虑最优QueryPlan的选取是找到最先执行完plan的索引,这里仍然不会选取{z:1,x:1}这个plan,而

     是会选取{x:1,z:1}这个plan.考虑到两个索引还不直观,这里加入一个{x:1},{x:1,z:1},{z:1,x:1},那么这里将会选择第

     一个索引{x:1}.要让mongod选择{z:1,x:1}这plan只能使用db.coll.find({x:{$lt:5,$gt:0}).sort({z:1}).hint({z:1,x:1}),

     总觉得这是一个bug,mongod应该能够修正这种情况才对,应该能自己选择最优的索引{z:1,x:1}才对.这里有一篇

     10gen的工程师谈mongodb索引优化的文章可以一看:

     http://www.csdn.net/article/2012-11-09/2811690-optimizing-mongodb-compound

上面介绍了那么多的流程情况下面正式进入代码分析阶段.接上篇文章runQuery->queryWithQueryOptimizer

[cpp]  view plain copy
  1. string queryWithQueryOptimizer( int queryOptions, const string& ns,  
  2.                                 const BSONObj &jsobj, CurOp& curop,  
  3.                                 const BSONObj &query, const BSONObj &order,  
  4.                                 const shared_ptr<ParsedQuery> &pq_shared,  
  5.                                 const BSONObj &oldPlan,  
  6.                                 const ConfigVersion &shardingVersionAtStart,  
  7.                                 scoped_ptr<PageFaultRetryableSection>& parentPageFaultSection,  
  8.                                 scoped_ptr<NoPageFaultsAllowed>& noPageFault,  
  9.                                 Message &result ) {  
  10.   
  11.     const ParsedQuery &pq( *pq_shared );  
  12.     shared_ptr<Cursor> cursor;  
  13.     QueryPlanSummary queryPlan;  
  14.       
  15.     if ( pq.hasOption( QueryOption_OplogReplay ) ) {//用于oplog的回放的游标.  
  16.         cursor = FindingStartCursor::getCursor( ns.c_str(), query, order );  
  17.     }  
  18.     else {  
  19.         cursor =//本文的主要分析的部分,游标的获取  
  20.             NamespaceDetailsTransient::getCursor( ns.c_str(), query, order, QueryPlanSelectionPolicy::any(),  
  21.                                                   0, pq_shared, false, &queryPlan );  
  22.     }  
  23.     scoped_ptr<QueryResponseBuilder> queryResponseBuilder  
  24.             ( QueryResponseBuilder::make( pq, cursor, queryPlan, oldPlan ) );  
  25.     bool saveClientCursor = false;  
  26.     OpTime slaveReadTill;  
  27.     ClientCursor::Holder ccPointer( new ClientCursor( QueryOption_NoCursorTimeout, cursor,  
  28.                                                      ns ) );  
  29.     for( ; cursor->ok(); cursor->advance() ) {  
  30.         bool yielded = false;//这里的查询机制,当查询时间超过了一个给定的值,这里为10ms或者在一段时间内调用该函数超过了128次,又或者cursor指向的文档不在内存中,那么这里将睡眠一会儿,睡眠的时间由当前系统中读取读者数目r和写者数目w,由10*r+w决定,单位为ms,最大值不超过1000000.  
  31.         if ( !ccPointer->yieldSometimes( ClientCursor::MaybeCovered, &yielded ) ||//睡眠前会通知游标保存当前位置  
  32.             !cursor->ok() ) {//这里是睡眠完成后发现当前游标失效了  
  33.             cursor.reset();  
  34.             queryResponseBuilder->noteYield();  
  35.             // !!! TODO The queryResponseBuilder still holds cursor.  Currently it will not do  
  36.             // anything unsafe with the cursor in handoff(), but this is very fragile.  
  37.             //  
  38.             // We don't fail the query since we're fine with returning partial data if the  
  39.             // collection was dropped.  
  40.             // NOTE see SERVER-2454.  
  41.             // TODO This is wrong.  The cursor could be gone if the closeAllDatabases command  
  42.             // just ran.  
  43.             break;  
  44.         }  
  45.         if ( yielded ) {//发生过yield,这是由两种情况构成，要么关心的数据不在内存，要么  
  46.             queryResponseBuilder->noteYield();//clientCursor超过了ccPointer->_yieldSometimesTracker规定的yield时间  
  47.         }  
  48.         if ( pq.getMaxScan() && cursor->nscanned() > pq.getMaxScan() ) {//超过了用户查询时设置的最大的扫描扫描数目  
  49.             break;  
  50.         }  
  51.         if ( !queryResponseBuilder->addMatch() ) {//具体查询的文档的匹配过程,下一篇文章将介绍  
  52.             continue;  
  53.         }  
  54.         // Note slave's position in the oplog.  
  55.         if ( pq.hasOption( QueryOption_OplogReplay ) ) {  
  56.             BSONObj current = cursor->current();  
  57.             BSONElement e = current["ts"];  
  58.             if ( e.type() == Date || e.type() == Timestamp ) {  
  59.                 slaveReadTill = e._opTime();  
  60.             }  
  61.         }  
  62.         if ( !cursor->supportGetMore() || pq.isExplain() ) {  
  63.             if ( queryResponseBuilder->enoughTotalResults() ) {  
  64.                 break;  
  65.             }  
  66.         }  
  67.         else if ( queryResponseBuilder->enoughForFirstBatch() ) {  
  68.             // if only 1 requested, no cursor saved for efficiency...we assume it is findOne()  
  69.             if ( pq.wantMore() && pq.getNumToReturn() != 1 ) {  
  70.                 queryResponseBuilder->finishedFirstBatch();  
  71.                 if ( cursor->advance() ) {  
  72.                     saveClientCursor = true;  
  73.                 }  
  74.             }  
  75.             break;  
  76.         }  
  77.     }  
  78.     if ( cursor ) {  
  79.         if ( pq.hasOption( QueryOption_CursorTailable ) && pq.getNumToReturn() != 1 ) {  
  80.             cursor->setTailable();  
  81.         }  
  82.         // If the tailing request succeeded.  
  83.         if ( cursor->tailable() ) {  
  84.             saveClientCursor = true;  
  85.         }  
  86.     }  
  87.     int nReturned = queryResponseBuilder->handoff( result );  
  88.     ccPointer.reset();  
  89.     long long cursorid = 0;  
  90.     if ( saveClientCursor ) {//保存cursor下一次客户端请求调用dbGetmore时直接从这里读出游标  
  91.         // Create a new ClientCursor, with a default timeout.  
  92.         ccPointer.reset( new ClientCursor( queryOptions, cursor, ns,  
  93.                                           jsobj.getOwned() ) );  
  94.         cursorid = ccPointer->cursorid();  
  95.         DEV tlog(2) << "query has more, cursorid: " << cursorid << endl;  
  96.         if ( cursor->supportYields() ) {  
  97.             ClientCursor::YieldData data;  
  98.             ccPointer->prepareToYield( data );  
  99.         }  
  100.         else {  
  101.             ccPointer->c()->noteLocation();  
  102.         }  
  103.         // Save slave's position in the oplog.  
  104.         if ( pq.hasOption( QueryOption_OplogReplay ) && !slaveReadTill.isNull() ) {  
  105.             ccPointer->slaveReadTill( slaveReadTill );  
  106.         }  
  107.         if ( !ccPointer->ok() && ccPointer->c()->tailable() ) {  
  108.             DEV tlog() << "query has no more but tailable, cursorid: " << cursorid << endl;  
  109.         }  
  110.         if( queryOptions & QueryOption_Exhaust ) {  
  111.             curop.debug().exhaust = true;  
  112.         }  
  113.         // Set attributes for getMore.  
  114.         ccPointer->setChunkManager( queryResponseBuilder->chunkManager() );  
  115.         ccPointer->setPos( nReturned );  
  116.         ccPointer->pq = pq_shared;  
  117.         ccPointer->fields = pq.getFieldPtr();  
  118.         ccPointer.release();  
  119.     }//返回结果集  
  120.     QueryResult *qr = (QueryResult *) result.header();  
  121.     qr->cursorId = cursorid;  
  122.     curop.debug().cursorid = ( cursorid == 0 ? -1 : qr->cursorId );  
  123.     qr->setResultFlagsToOk();  
  124.     // qr->len is updated automatically by appendData()  
  125.     curop.debug().responseLength = qr->len;  
  126.     qr->setOperation(opReply);  
  127.     qr->startingFrom = 0;  
  128.     qr->nReturned = nReturned;  
  129.     int duration = curop.elapsedMillis();  
  130.     bool dbprofile = curop.shouldDBProfile( duration );//记录查询命令  
  131.     if ( dbprofile || duration >= cmdLine.slowMS ) {  
  132.         curop.debug().nscanned = ( cursor ? cursor->nscanned() : 0LL );  
  133.         curop.debug().ntoskip = pq.getSkip();  
  134.     }  
  135.     curop.debug().nreturned = nReturned;  
  136.     return curop.debug().exhaust ? ns : "";  
  137. }  

继续来看游标的产生:

NamespaceDetailsTransient::getCursor->CursorGenerator::generate

[cpp]  view plain copy
  1. shared_ptr<Cursor> CursorGenerator::generate() {  
  2.     setArgumentsHint();//设置查询使用的索引,来自于db.coll.find({x:1}).hint({xx:1})的hint函数.mongodb提供一个snapshot的选项,当设置了snapshot时强制使用索引_id.这里有一篇文章介绍snapshot的特性:<a href="http://www.cnblogs.com/silentcross/archive/2011/07/04/2095424.html">http://www.cnblogs.com/silentcross/archive/2011/07/04/2095424.html</a>  
  3.     shared_ptr<Cursor> cursor = shortcutCursor();//这里要么查询是空的且排序是空的,则返回一个集合扫描的Cursor,要么是按照简单的_id查询  
  4.     if ( cursor ) {                              //返回一个_id索引的BtreeCursor.  
  5.         return cursor;  
  6.     }  
  7.     setMultiPlanScanner();//创建查询范围,生成plan.  
  8.     cursor = singlePlanCursor()//如果只有单个plan生成则根据plan生成对应的cursor  
  9.     if ( cursor ) {  
  10.         return cursor;  
  11.     }//多plan优化  
  12.     return newQueryOptimizerCursor( _mps, _planPolicy, isOrderRequired(), explain() );  
  13. }  
继续前进看看setMultiPlanScanner:

[cpp]  view plain copy
  1. void CursorGenerator::setMultiPlanScanner() {//基本这里所有的make都干两件事,1是分配对应的对象,二是调用其初始化函数init初始化  
  2.     _mps.reset( MultiPlanScanner::make( _ns, _query, _order, _parsedQuery, hint(),  
  3.                                        explain() ? QueryPlanGenerator::Ignore :  
  4.                                             QueryPlanGenerator::Use,  
  5.                                        min(), max() ) );  
  6. }  
这里跳过分配对象的new操作直接进入init函数:

[cpp]  view plain copy
  1. void MultiPlanScanner::init( const BSONObj &order, const BSONObj &min, const BSONObj &max ) {  
  2.     if ( !order.isEmpty() || !min.isEmpty() || !max.isEmpty() ) {  
  3.         _or = false;//_or是根据传入的query中是否有$or标志设置的  
  4.     }  
  5.     if ( _or ) {//这里的OrRangeGenerator和下面的FieldRangeSetPair其实都是用来确定查询域的范围的,通过这个范围来直接定位Btree的位置,跳过不必要的btree数据对象扫描,当没有相应的索引时,这里建立的查询域范围将是无用的.  
  6.         // Only construct an OrRangeGenerator if we may handle $or clauses.  
  7.         _org.reset( new OrRangeGenerator( _ns.c_str(), _query ) );  
  8.         if ( !_org->getSpecial().empty() ) {  
  9.             _or = false;  
  10.         }  
  11.         else if ( haveUselessOr() ) {//对于如{$or:[{x:1},{y:1}]},这里要存在index:x,y时_or才不会被设置_or=false,前面描述过程时说到过  
  12.             _or = false;  
  13.         }  
  14.     }  
  15.     // if _or == false, don't use or clauses for index selection  
  16.     if ( !_or ) {  
  17.         ++_i;//若query为{$or:[{a:1},{:1}]}这种以or开头的语句，那么frsp是无用的,具体见FieldRangeSet::handleMatchField  
  18.         auto_ptr<FieldRangeSetPair> frsp( new FieldRangeSetPair( _ns.c_str(), _query, true ) );  
  19.         updateCurrentQps( QueryPlanSet::make( _ns.c_str(), frsp, auto_ptr<FieldRangeSetPair>(),  
  20.                                              _query, order, _parsedQuery, _hint,  
  21.                                              _recordedPlanPolicy,  
  22.                                              min, max, true ) );  
  23.     }  
  24.     else {  
  25.         BSONElement e = _query.getField( "$or" );  
  26.         massert( 13268, "invalid $or spec",  
  27.                 e.type() == Array && e.embeddedObject().nFields() > 0 );  
  28.         handleBeginningOfClause();  
  29.     }  
  30. }  
[cpp]  view plain copy
  1. OrRangeGenerator::OrRangeGenerator( const char *ns, const BSONObj &query , bool optimize )  
  2. : _baseSet( ns, query, optimize ), _orFound() {  
  3.       
  4.     BSONObjIterator i( _baseSet.originalQuery() );  
  5.     //取出所有的$or开始的对象,分别创建一个FieldRangeSetPair  
  6.     while( i.more() ) {//just like{$or:[{a:1},{b:1}], $or[{c:1},{d:1}]....}  
  7.         BSONElement e = i.next();  
  8.         if ( strcmp( e.fieldName(), "$or" ) == 0 ) {  
  9.             uassert( 13262, "$or requires nonempty array", e.type() == Array && e.embeddedObject().nFields() > 0 );  
  10.             BSONObjIterator j( e.embeddedObject() );  
  11.             while( j.more() ) {  
  12.                 BSONElement f = j.next();  
  13.                 uassert( 13263, "$or array must contain objects", f.type() == Object );  
  14.                 _orSets.push_back( FieldRangeSetPair( ns, f.embeddedObject(), optimize ) );  
  15.                 uassert( 13291, "$or may not contain 'special' query", _orSets.back().getSpecial().empty() );  
  16.                 _originalOrSets.push_back( _orSets.back() );  
  17.             }  
  18.             _orFound = true;  
  19.             continue;  
  20.         }  
  21.     }  
  22. }  
继续看FieldRangeSetPair:
[cpp]  view plain copy
  1. FieldRangeSetPair( const char *ns, const BSONObj &query, bool optimize=true )  
  2. :_singleKey( ns, query, true, optimize ), _multiKey( ns, query, false, optimize ) {}  
       _singleKey对应于单索引,_multikey对应于多值索引.mongodb提供一个multiKey的索引,简单来说就是当创建一个

索引如:db.coll.ensureIndex({x:1})时,当不存在x:[xx,xxx,xxxx]这种数据时那么这个索引x就是单值索引,当插入一条数据中

包括了x:[xx,xxx,xxx]这种array结构的x时,x变为多值索引.多值索引简单来说就是就是对于array中的每一个之建立一个索引.

继续前进到_singleKey对象的构造函数:

[cpp]  view plain copy
  1. FieldRangeSet::FieldRangeSet( const char *ns, const BSONObj &query, bool singleKey,  
  2.                              bool optimize ) :  
  3. _ns( ns ),  
  4. _queries( 1, query.getOwned() ),  
  5. _singleKey( singleKey ),  
  6. _exactMatchRepresentation( true ),  
  7. _boundElemMatch( true ) {  
  8.     init( optimize );  
  9. }  
[cpp]  view plain copy
  1. void FieldRangeSet::init( bool optimize ) {  
  2.     BSONObjIterator i( _queries[ 0 ] );  
  3.     while( i.more() ) {  
  4.         handleMatchField( i.next(), optimize );  
  5.     }  
  6. }  
[cpp]  view plain copy
  1. void FieldRangeSet::handleMatchField( const BSONElement& matchElement, bool optimize ) {  
  2.     const char* matchFieldName = matchElement.fieldName();  
  3.     if ( matchFieldName[ 0 ] == '$' ) {  
  4.         if ( str::equals( matchFieldName, "$and" ) ) {//$and对象对于$and中的每一个查询调用handleMatchField递归处理  
  5.             uassert( 14816, "$and expression must be a nonempty array",  
  6.                      matchElement.type() == Array &&  
  7.                      matchElement.embeddedObject().nFields() > 0 );  
  8.             handleConjunctionClauses( matchElement.embeddedObject(), optimize );  
  9.             return;  
  10.         }  
  11.         adjustMatchField();  
  12.         if ( str::equals( matchFieldName, "$or" ) ) {//这里出现了这种形式:$or:[{xxx:1}],只有一个分支,也是调用  
  13.             // Check for a singleton $or expression. //handleMatchField递归处理  
  14.             if ( matchElement.type() == Array &&  
  15.                  matchElement.embeddedObject().nFields() == 1 ) {  
  16.                 // Compute field bounds for a singleton $or expression as if it is a $and  
  17.                 // expression.  With only one clause, the matching semantics are the same.  
  18.                 // SERVER-6416  
  19.                 handleConjunctionClauses( matchElement.embeddedObject(), optimize );  
  20.             }  
  21.             return;  
  22.         }  
  23.         if ( str::equals( matchFieldName, "$nor" ) ) {  
  24.             return;  
  25.         }  
  26.         if ( str::equals( matchFieldName, "$where" ) ) {  
  27.             return;  
  28.         }  
  29.     }  
  30.     //just like {x: 1} or {x : {y : 1, z : 2}}  
  31.     bool equality =  
  32.         // Check for a parsable '$' operator within a match element, indicating the object  
  33.         // should not be matched as is but parsed.  
  34.         // NOTE This only checks for a '$' prefix in the first embedded field whereas Matcher  
  35.         // checks all embedded fields.  
  36.         ( getGtLtOp( matchElement ) == BSONObj::Equality ) &&  
  37.         // Similarly check for the $not meta operator.  
  38.         !( matchElement.type() == Object &&//这里对于intersectMatchField以及其内部的内容就不再做分析了,写出来太多  
  39.            str::equals( matchElement.embeddedObject().firstElementFieldName(), "$not" ) );  
  40.     if ( equality ) {//这里将建立一个matchFieldName的FieldRange结构,然后和之前可能存在的这个域的FieldRange结构做运算  
  41.         intersectMatchField( matchFieldName, matchElement, false, optimize );//得到新的matchFieldName的范围  
  42.         return;  
  43.     }  
  44.     bool untypedRegex =  
  45.         ( matchElement.type() == Object ) &&//like {x: {$regex: /acme.*corp/i, $nin: ['acmeblahcorp']}}  
  46.         matchElement.embeddedObject().hasField( "$regex" );//like {x:{$regex: 'acme.*corp', $options:'i'}}  
  47.     if ( untypedRegex ) {  
  48.         // $regex/$options pairs must be handled together and so are passed via the  
  49.         // element encapsulating them.  
  50.         intersectMatchField( matchFieldName, matchElement, false, optimize );  
  51.         // Other elements may remain to be handled, below.  
  52.     }//这里是处理类似{x:{$elemMatch:{y:1,z:2}}},{x:{$all:[1,2,3]}}这种查询语句  
  53.     BSONObjIterator matchExpressionIterator( matchElement.embeddedObject() );  
  54.     while( matchExpressionIterator.more() ) {  
  55.         BSONElement opElement = matchExpressionIterator.next();  
  56.         if ( str::equals( opElement.fieldName(), "$not" ) ) {  
  57.             handleNotOp( matchFieldName, opElement, optimize );  
  58.         }  
  59.         else {  
  60.             handleOp( matchFieldName, opElement, false, optimize );  
  61.         }  
  62.     }  
  63. }  
[cpp]  view plain copy
  1. void FieldRangeSet::handleOp( const char* matchFieldName, const BSONElement& op, bool isNot,  
  2.                               bool optimize ) {  
  3.     int opType = op.getGtLtOp();  
  4.     // If the first $all element's first op is an $elemMatch, generate bounds for it  
  5.     // and ignore the remaining $all elements.  SERVER-664  
  6.     if ( opType == BSONObj::opALL ) {//类似这种{x:{$all:[{$elemMatch:{k:1,f:1}},{x:1},{z:1}]}},则这里只处理其中的第一个element  
  7.         uassert( 13050, "$all requires array", op.type() == Array );  
  8.         BSONElement firstAllClause = op.embeddedObject().firstElement();  
  9.         if ( firstAllClause.type() == Object ) {  
  10.             BSONElement firstAllClauseOp = firstAllClause.embeddedObject().firstElement();  
  11.             if ( firstAllClauseOp.getGtLtOp() == BSONObj::opELEM_MATCH ) {  
  12.                 handleElemMatch( matchFieldName, firstAllClauseOp, isNot, optimize );  
  13.                 return;  
  14.             }  
  15.         }  
  16.     }//不再深入到HandleElemMatch函数内部,简单说一下,对于{$elemMatch:{k:1,y:2}}这种语句就是再建立一个FieldRangeSet并对其内部  
  17.     if ( opType == BSONObj::opELEM_MATCH ) {//的{k:1,y:2}做处理,得到的FieldRangeSet与当前的FieldRangeSet做与运算,得到的结果  
  18.         handleElemMatch( matchFieldName, op, isNot, optimize );//保存到当前FieldRangeSet中  
  19.     }  
  20.     else {  
  21.         intersectMatchField( matchFieldName, op, isNot, optimize );  
  22.     }  
  23. }  

回到MultiPlanScanner::init继续前进看看:QueryPlanSet::make函数.

[cpp]  view plain copy
  1. auto_ptr<FieldRangeSetPair> frsp( new FieldRangeSetPair( _ns.c_str(), _query, true ) );  
  2. updateCurrentQps( QueryPlanSet::make( _ns.c_str(), frsp, auto_ptr<FieldRangeSetPair>(),  
  3.                                      _query, order, _parsedQuery, _hint,  
  4.                                      _recordedPlanPolicy,  
  5.                                      min, max, true ) );  
签名说过make函数是new一个QueryPlanSet并且调用其init函数继续看init函数:

[cpp]  view plain copy
  1. void QueryPlanSet::init() {  
  2.     DEBUGQO( "QueryPlanSet::init " << ns << "\t" << _originalQuery );  
  3.     _plans.clear();//清空plans,这里将是plan的选取  
  4.     _usingCachedPlan = false;  
  5.     _generator.addInitialPlans();  
  6. }  
[cpp]  view plain copy
  1. void QueryPlanGenerator::addInitialPlans() {  
  2.     const char *ns = _qps.frsp().ns();  
  3.     NamespaceDetails *d = nsdetails( ns );  
  4.     if ( addShortCircuitPlan( d ) ) {//这里直接选择单个plan,下面看看这里添加的plan都是什么状况  
  5.         return;  
  6.     }  
  7.     addStandardPlans( d );//根据索引实际添加的plan  
  8.     warnOnCappedIdTableScan();  
  9. }  
QueryPlanGenerator::addInitialPlans->QueryPlanGenerator::addShortCircuitPlan:

[cpp]  view plain copy
  1. bool QueryPlanGenerator::addShortCircuitPlan( NamespaceDetails *d ) {  
  2.     return//1 集合不存在,2 不可能有match的索引,3 hint指定选择索引的plan, 4使用特殊索引的plan如:  
  3.         // The collection is missing.//空间地理索引,5无法指定范围并且排序为空的plan,6指定排序  
  4.         setUnindexedPlanIf( !d, d ) ||//不为空为$natural(这个是按照插入顺序排序的要求)的plan  
  5.         // No match is possible.//这几种情况下选择的plan都是一定的,不存在多plan的情况  
  6.         setUnindexedPlanIf( !_qps.frsp().matchPossible(), d ) ||  
  7.         // The hint, min, or max parameters are specified.  
  8.         addHintPlan( d ) ||  
  9.         // A special index operation is requested.  yhjj0108 add -- maybe for special index 2d and so on  
  10.         addSpecialPlan( d ) ||  
  11.         // No indexable ranges or ordering are specified.  
  12.         setUnindexedPlanIf( _qps.frsp().noNonUniversalRanges() && _qps.order().isEmpty(), d ) ||  
  13.         // $natural sort is requested.  
  14.         setUnindexedPlanIf( !_qps.order().isEmpty() &&  
  15.                            str::equals( _qps.order().firstElementFieldName(), "$natural" ), d );  
  16. }  
继续QueryPlanGenerator::addInitialPlans->QueryPlanGenerator::addStandardPlans:

[cpp]  view plain copy
  1. void QueryPlanGenerator::addStandardPlans( NamespaceDetails *d ) {  
  2.     if ( !addCachedPlan( d ) ) {//plan已经被缓存了,表示执行过一次该查询以上,上一次已经找出了最优的  
  3.         addFallbackPlans();//plan,这一次直接取出最优的plan就行了.  
  4.     }  
  5. }  
QueryPlanGenerator::addInitialPlans->QueryPlanGenerator::addStandardPlans->QueryPlanGenerator::addFallbackPlans

在继续之前这里需要说明的是mongodb的plan分5种:

[cpp]  view plain copy
  1. enum Utility {  
  2.     Impossible, // Cannot produce any matches, so the query must have an empty result set.  
  3.                 // No other plans need to be considered.  
  4.     Optimal,    // Should run as the only candidate plan in the absence of an Impossible  
  5.                 // plan.  
  6.     Helpful,    // Should be considered.  
  7.     Unhelpful,  // Should not be considered.  
  8.     Disallowed  // Must not be considered unless explicitly hinted.  May produce a  
  9.                 // semantically incorrect result set.  
  10. };  
Impossible:完全无法匹配的,如查询是db.coll.find({x:{$lt:5,$gt:10}})这种产生的FieldRangeSetPair中的域

                     时会产生一个空的range,进而产生完全无法匹配的状况.

Optimal:    FieldRangeSetPair中每一个域都在索引中,这是一个最优的索引,根据这个索引产生的plan

                   将是最优的,不需要再考虑其它plan了.

Helpful:    选择的索引能够覆盖FieldRangeSetPair中的部分域,这个索引是有用的,虽然可能会多搜索
                  一些不会匹配其它域的document.在没有Optimal索引的情况下会根据Helpful索引建立plan
                 有多个Helpful的索引将建立多plan.

Unhelpful:无用的索引,不会考虑,似乎和Impossible差不多.

Disallowed: 如果使用这个索引查询数据可能会出错,这里有一个sparse的概念.mongodb的普通索引

                      是会索引无关数据的,举例来说有索引{x:1},插入一条数据{y:10},那么索引也会把这条数据

                      索引了,但是建立sparse索引db.xxx.ensureIndex({x:1},{sparse:true})那么这里的索引将

                      不再索引{y:10}这条数据了.对于sparse索引并且存在类似{z:{$exist:false}}这种情况,那么

                      使用该索引结果可能是不正确的不考虑该索引.

下面继续看代码:

[cpp]  view plain copy
  1.    void QueryPlanGenerator::addFallbackPlans() {  
  2.        const char *ns = _qps.frsp().ns();  
  3.        NamespaceDetails *d = nsdetails( ns );  
  4.        vector<shared_ptr<QueryPlan> > plans;  
  5.        shared_ptr<QueryPlan> optimalPlan;  
  6.        shared_ptr<QueryPlan> specialPlan;  
  7.        for( int i = 0; i < d->nIndexes; ++i ) {//遍历所有索引,找出有用的索引,indexUseful指只要索引中  
  8.            if ( !QueryUtilIndexed::indexUseful( _qps.frsp(), d, i, _qps.order() ) ) {//有一个域覆盖了  
  9.                continue;//查询条件或者排序条件那么这个索引就是有用的  
  10.            }//根据索引建立一个plan,通过建立的plan得出其是否是有用的  
  11.            shared_ptr<QueryPlan> p = newPlan( d, i );  
  12.            switch( p->utility() ) {  
  13.                case QueryPlan::Impossible://后面将会看到对于这个plan若只存在其  
  14.                    _qps.setSinglePlan( p );//那么将建立一个有0个文档的cursor  
  15.                    return;  
  16.                case QueryPlan::Optimal://最优的plan,有则肯定选择它  
  17.                    if ( !optimalPlan ) {  
  18.                        optimalPlan = p;  
  19.                    }  
  20.                    break;  
  21.                case QueryPlan::Helpful://这个plan是有帮助的记录其  
  22.                    if ( p->special().empty() ) {  
  23.                        // Not a 'special' plan.  
  24.                        plans.push_back( p );  
  25.                    }  
  26.                    else if ( _allowSpecial ) {//类似空间地理索引这种索引插件产生的索引plan  
  27.                        specialPlan = p;  
  28.                    }  
  29.                    break;  
  30.                default:  
  31.                    break;  
  32.            }  
  33.        }  
  34.        if ( optimalPlan ) {//最优的plan,有人肯呢个会问如果存在impossible的plan后那么这里的  
  35.            _qps.setSinglePlan( optimalPlan );//setSinglePlan会插入不进去,其实不用担心,impossible表示完全无法匹配如:y>10 and y<3这种情况,那么任意的plan都无法匹配,自然无法产生optimalPlan了.  
  36.            // Record an optimal plan in the query cache immediately, with a small nscanned value  
  37.            // that will be ignored.  
  38.            optimalPlan->registerSelf//将其注册为最优的plan,以后可以直接使用这个plan而不用比对哪个plan最优了  
  39.                    ( 0, CandidatePlanCharacter( !optimalPlan->scanAndOrderRequired(),  
  40.                                                optimalPlan->scanAndOrderRequired() ) );  
  41.            return;  
  42.        }  
  43.        // Only add a special plan if no standard btree plans have been added. SERVER-4531  
  44.        if ( plans.empty() && specialPlan ) {  
  45.            _qps.setSinglePlan( specialPlan );  
  46.            return;  
  47.        }  
  48. //对于这种db.coll.find({x:1,y:1}),存在着索引{key:{x:1}},{key:{y:1}},两者都不是最优的  
  49. //所以这里产生了两个QueryPlan,分别是{key:{x:1}}和{key:{y:1}}  
  50.        for( vector<shared_ptr<QueryPlan> >::const_iterator i = plans.begin(); i != plans.end();  
  51.            ++i ) {//将所有的planplan键入到候选plan中.  
  52.            _qps.addCandidatePlan( *i );  
  53.        }//最后加入一个不使用索引的plan.          
  54.        _qps.addCandidatePlan( newPlan( d, -1 ) );  
  55.    }  

继续来看看newPlan函数,这个函数包括了一个plan的构造.其同样是new一个QueryPlan然后调用其init函数:

[cpp]  view plain copy
  1.     QueryPlan::QueryPlan( NamespaceDetails *d,  
  2.                          int idxNo,  
  3.                          const FieldRangeSetPair &frsp,  
  4.                          const BSONObj &originalQuery,  
  5.                          const BSONObj &order,  
  6.                          const shared_ptr<const ParsedQuery> &parsedQuery,  
  7.                          string special ) :  
  8.         _d(d),  
  9.         _idxNo(idxNo),  
  10.         _frs( frsp.frsForIndex( _d, _idxNo ) ),  
  11.         _frsMulti( frsp.frsForIndex( _d, -1 ) ),  
  12.         _originalQuery( originalQuery ),  
  13.         _order( order ),  
  14.         _parsedQuery( parsedQuery ),  
  15.         _index( 0 ),  
  16.         _scanAndOrderRequired( true ),//默认是需要排序的  
  17.         _exactKeyMatch( false ),  
  18.         _direction( 0 ),  
  19.         _endKeyInclusive(),  
  20.         _utility( Helpful ),//默认索引是有用的  
  21.         _special( special ),  
  22.         _type(0),  
  23.         _startOrEndSpec() {  
  24.     }  
  25.     void QueryPlan::init( const FieldRangeSetPair *originalFrsp,  
  26.                          const BSONObj &startKey,  
  27.                          const BSONObj &endKey ) {  
  28.         _endKeyInclusive = endKey.isEmpty();  
  29.         _startOrEndSpec = !startKey.isEmpty() || !endKey.isEmpty();  
  30.         BSONObj idxKey = _idxNo < 0 ? BSONObj() : _d->idx( _idxNo ).keyPattern();  
  31.         if ( !_frs.matchPossibleForIndex( idxKey ) ) {//Impossible的状况,这个plan是无用的  
  32.             _utility = Impossible;  
  33.             _scanAndOrderRequired = false;  
  34.             return;  
  35.         }  
  36.         if ( willScanTable() ) {//索引编号为-1(newplan(xxx,-1))且plan不为Impossible,那么只能扫描全表了  
  37.             if ( _order.isEmpty() || !strcmp( _order.firstElementFieldName(), "$natural" ) )  
  38.                 _scanAndOrderRequired = false;//要么order为空，要么order指定为$natural(自然序列，那么都不需要排序了)  
  39.             return;  
  40.         }  
  41.         _index = &_d->idx(_idxNo);//得到索引  
  42.         // If the parsing or index indicates this is a special query, don't continue the processing  
  43.         if ( _special.size() ||//这部分的代码和索引插件有关,就是类似空间地理索引的处理流程  
  44.             ( _index->getSpec().getType() &&//跳过  
  45.              _index->getSpec().getType()->suitability( _originalQuery, _order ) != USELESS ) ) {  
  46.             _type  = _index->getSpec().getType();  
  47.             if( !_special.size() ) _special = _index->getSpec().getType()->getPlugin()->getName();  
  48.             massert( 13040 , (string)"no type for special: " + _special , _type );  
  49.             // hopefully safe to use original query in these contexts;  
  50.             // don't think we can mix special with $or clause separation yet  
  51.             _scanAndOrderRequired = _type->scanAndOrderRequired( _originalQuery , _order );  
  52.             return;  
  53.         }  
  54.         const IndexSpec &idxSpec = _index->getSpec();  
  55.         BSONObjIterator o( _order );  
  56.         BSONObjIterator k( idxKey );  
  57.         if ( !o.moreWithEOO() )//索引与排序要求匹配,排序要求先结束那么扫描完了后  
  58.             _scanAndOrderRequired = false;//不需要再排序  
  59.         while( o.moreWithEOO() ) {  
  60.             BSONElement oe = o.next();  
  61.             if ( oe.eoo() ) {  
  62.                 _scanAndOrderRequired = false;  
  63.                 break;  
  64.             }  
  65.             if ( !k.moreWithEOO() )  
  66.                 break;  
  67.             BSONElement ke;  
  68.             while( 1 ) {  
  69.                 ke = k.next();  
  70.                 if ( ke.eoo() )  
  71.                     goto doneCheckOrder;  
  72.                 if ( strcmp( oe.fieldName(), ke.fieldName() ) == 0 )  
  73.                     break;  
  74.                 if ( !_frs.range( ke.fieldName() ).equality() )  
  75.                     goto doneCheckOrder;  
  76.             }//索引的顺序与排序要求相反,则使用反序  
  77.             int d = elementDirection( oe ) == elementDirection( ke ) ? 1 : -1;  
  78.             if ( _direction == 0 )  
  79.                 _direction = d;  
  80.             else if ( _direction != d )  
  81.                 break;  
  82.         }  
  83. doneCheckOrder:  
  84.         if ( _scanAndOrderRequired )  
  85.             _direction = 0;  
  86.         BSONObjIterator i( idxKey );  
  87.         int exactIndexedQueryCount = 0;  
  88.         int optimalIndexedQueryCount = 0;  
  89.         bool awaitingLastOptimalField = true;  
  90.         set<string> orderFieldsUnindexed;  
  91.         _order.getFieldNames( orderFieldsUnindexed );  
  92.         while( i.moreWithEOO() ) {  
  93.             BSONElement e = i.next();  
  94.             if ( e.eoo() )  
  95.                 break;  
  96.             const FieldRange &fr = _frs.range( e.fieldName() );  
  97.             if ( awaitingLastOptimalField ) {//这个索引有用,则OptimalIndexedQueryCount++,这里回到之前讨论的问题,查询为db.coll.find({x:{$lt:10,$gt:4}}).sort{y:1},当存在索引时{x:1},{x:1,y:1},{y:1,x:1},这里本来{y:1,x:1}应该是最优的索引,当使用其时前面会将_scanAndOrderRequired设置为false,这里遍历y时第一个进入这里时因为y不在查询内容中,所以fr.universal()为false,为universal()范围最大值为maxkey,最小为minkey,mongodb中maxkey大于其它一切数据,minkey小于其它一切数据,所以fr.equality()为false,那么awaitingLastOptmalField=false,第二次x遍历时走x路线,optimalIndexedQueryCount=-1,  
  98.                 if ( !fr.universal() )  
  99.                     ++optimalIndexedQueryCount;  
  100.                 if ( !fr.equality() )  
  101.                     awaitingLastOptimalField = false;  
  102.             }  
  103.             else {  
  104.                 if ( !fr.universal() )  
  105.                     optimalIndexedQueryCount = -1;  
  106.             }  
  107.             if ( fr.equality() ) {  
  108.                 BSONElement e = fr.max();  
  109.                 if ( !e.isNumber() && !e.mayEncapsulate() && e.type() != RegEx )  
  110.                     ++exactIndexedQueryCount;  
  111.             }  
  112.             orderFieldsUnindexed.erase( e.fieldName() );  
  113.         }  
  114.         if ( !_scanAndOrderRequired &&//不需要排序并且索引有效的个数和之前得到的查询域的有效范围相等,那么这是最优的一个plan了.  
  115.                 ( optimalIndexedQueryCount == _frs.numNonUniversalRanges() ) )  
  116.             _utility = Optimal;  
  117.         if ( exactIndexedQueryCount == _frs.numNonUniversalRanges() &&  
  118.             orderFieldsUnindexed.size() == 0 &&  
  119.             exactIndexedQueryCount == idxKey.nFields() &&  
  120.             exactKeyMatchSimpleQuery( _originalQuery, exactIndexedQueryCount ) ) {  
  121.             _exactKeyMatch = true;  
  122.         }  
  123.         _frv.reset( new FieldRangeVector( _frs, idxSpec, _direction ) );  
  124.         if ( originalFrsp ) {  
  125.             _originalFrv.reset( new FieldRangeVector( originalFrsp->frsForIndex( _d, _idxNo ),  
  126.                                                      idxSpec, _direction ) );  
  127.         }  
  128.         else {  
  129.             _originalFrv = _frv;  
  130.         }  
  131.         if ( _startOrEndSpec ) {  
  132.             BSONObj newStart, newEnd;  
  133.             if ( !startKey.isEmpty() )  
  134.                 _startKey = startKey;  
  135.             else  
  136.                 _startKey = _frv->startKey();  
  137.             if ( !endKey.isEmpty() )  
  138.                 _endKey = endKey;  
  139.             else  
  140.                 _endKey = _frv->endKey();  
  141.         }  
  142.         if ( ( _scanAndOrderRequired || _order.isEmpty() ) &&   
  143.             _frs.range( idxKey.firstElementFieldName() ).universal() ) { // NOTE SERVER-2140  
  144.             _utility = Unhelpful;  
  145.         }             
  146.         if ( idxSpec.isSparse() && hasPossibleExistsFalsePredicate() ) {//  
  147.             _utility = Disallowed;  
  148.         }  
  149.         if ( _parsedQuery && _parsedQuery->getFields() && !_d->isMultikey( _idxNo ) ) { // Does not check modifiedKeys()  
  150.             _keyFieldsOnly.reset( _parsedQuery->getFields()->checkKey( _index->keyPattern() ) );  
  151.         }  
  152.     }  
        这里探讨一个问题,我之前一直觉得上面代码中应该是有办法判断{x:1}和{y:1,x:1}的优劣的,加入相应

条件就能够达到要求找到最优的plan{y:1,x:1},为什么不选择这个plan呢,难道说考虑到要插入这种

{y:40}这种数据吗,虽然{x:1}这种索引没有y域但是其还是会对这个{y:40}数据加入索引啊,数目并不会

比{y:1,x:1}这个索引的数目多啊,而且{y:1,x:1},但是后来我发现我忽略了一个问题,索引{y:1,x:1}无法直接定

位到x的范围,那么查询的无关的document数目可能比{x:1}这个索引查询的数目多,对于mongodb优化考

虑的是如何得到最少的document扫描数目,所以{y:1,x:1}也只能是一个可考虑的索引而无法成为最优的

索引,所以要想让查询使用这个索引只能使用hint了.

这篇文件就暂时写到这里,后面还有很多内容,一篇文章写下来太多,还是分成两篇文章吧,关于plan的

选取请看下一篇文章.


本文链接:http://blog.csdn.net/yhjj0108/article/details/8257081

作者:yhjj0108,杨浩


声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/140804
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号