Merge remote branch 'main_readonly/master'

dwight · dwight · commit 83a9a19571c1 · 2012-03-14T10:56:31.000-04:00
diff --git a/jstests/explain4.js b/jstests/explain4.js
@@ -1,43 +1,43 @@
-// Basic validation of explain output fields
+// Basic validation of explain output fields.
 
 t = db.jstests_explain4;
 t.drop();
 
-function checkField( name, value ) {
+function checkField( explain, name, value ) {
     assert( explain.hasOwnProperty( name ) );
     if ( value != null ) {
         assert.eq( value, explain[ name ], name );
     }
 }
 
 function checkPlanFields( explain, matches, n ) {
-    checkField( "cursor", "BasicCursor" );
-    checkField( "n", n );
-    checkField( "nscannedObjects", matches );
-    checkField( "nscanned", matches );    
-    checkField( "indexBounds", {} );
+    checkField( explain, "cursor", "BasicCursor" );
+    checkField( explain, "n", n );
+    checkField( explain, "nscannedObjects", matches );
+    checkField( explain, "nscanned", matches );    
+    checkField( explain, "indexBounds", {} );
 }
 
 function checkFields( matches, sort, limit ) {
-    it = t.find();
+    cursor = t.find();
     if ( sort ) {
-        it.sort({a:1});
+        cursor.sort({a:1});
     }
     if ( limit ) {
-        it.limit( limit );
+        cursor.limit( limit );
     }
-    explain = it.explain( true );
+    explain = cursor.explain( true );
 //    printjson( explain );
     checkPlanFields( explain, matches, matches > 0 ? 1 : 0 );
-    checkField( "scanAndOrder", sort );
-    checkField( "millis" );
-    checkField( "nYields" );
-    checkField( "nChunkSkips", 0 );
-    checkField( "isMultiKey", false );
-    checkField( "indexOnly", false );
-    checkField( "server" );
-    checkField( "allPlans" );
-    explain.allPlans.forEach( function( x ) { checkPlanFields( x, matches ); } );
+    checkField( explain, "scanAndOrder", sort );
+    checkField( explain, "millis" );
+    checkField( explain, "nYields" );
+    checkField( explain, "nChunkSkips", 0 );
+    checkField( explain, "isMultiKey", false );
+    checkField( explain, "indexOnly", false );
+    checkField( explain, "server" );
+    checkField( explain, "allPlans" );
+    explain.allPlans.forEach( function( x ) { checkPlanFields( x, matches, matches ); } );
 }
 
 checkFields( 0, false );
diff --git a/jstests/explain5.js b/jstests/explain5.js
@@ -11,6 +11,20 @@ for( i = 0; i < 10; ++i ) {
     t.save( {} );
 }
 
+// Check with a single in order plan.
+
+explain = t.find( {a:{$gt:0}} ).explain( true );
+assert.eq( 1, explain.n );
+assert.eq( 1, explain.allPlans[ 0 ].n );
+
+// Check with a single out of order plan.
+
+explain = t.find( {a:{$gt:0}} ).sort( {z:1} ).hint( {a:1} ).explain( true );
+assert.eq( 1, explain.n );
+assert.eq( 1, explain.allPlans[ 0 ].n );
+
+// Check with multiple plans.
+
 explain = t.find( {a:{$gt:0},b:{$gt:0}} ).explain( true );
 assert.eq( 1, explain.n );
 assert.eq( 1, explain.allPlans[ 0 ].n );
diff --git a/jstests/explain6.js b/jstests/explain6.js
@@ -20,4 +20,4 @@ t.dropIndexes();
 explain = t.find().skip( 1 ).sort({a:1}).explain( true );
 // Skip is applied for an in memory sort.
 assert.eq( 0, explain.n );
-assert.eq( 0, explain.allPlans[ 0 ].n );
+assert.eq( 1, explain.allPlans[ 0 ].n );
diff --git a/jstests/explain9.js b/jstests/explain9.js
@@ -0,0 +1,24 @@
+// Test that limit is applied by explain when there are both in order and out of order candidate
+// plans.  SERVER-4150
+
+t = db.jstests_explain9;
+t.drop();
+
+t.ensureIndex( { a:1 } );
+
+for( i = 0; i < 10; ++i ) {
+    t.save( { a:i, b:0 } );
+}
+
+explain = t.find( { a:{ $gte:0 }, b:0 } ).sort( { a:1 } ).limit( 5 ).explain( true );
+// Five results are expected, matching the limit spec.
+assert.eq( 5, explain.n );
+explain.allPlans.forEach( function( x ) {
+                         // Five results are expected for the in order plan.
+                         if ( x.cursor == "BtreeCursor a_1" ) {
+                             assert.eq( 5, x.n );
+                         }
+                         else {
+                             assert.gte( 5, x.n );
+                         }
+                         } );
diff --git a/jstests/updatek.js b/jstests/updatek.js
@@ -5,9 +5,12 @@ t = db.jstests_updatek;
 t.drop();
 t.save( { _id:0, '1':{}, '01':{} } );
 t.update( {}, { $set:{ '1.b':1, '1.c':2 } } );
-assert.eq( { '01':{}, '1':{ b:1, c:2 }, _id:0 }, t.findOne() );
+// make sure correct fields are set, with no duplicates
+// must use string comparison because V8 reorders fields that are numerical in objects
+assert.eq( "{ \"01\" : { }, \"1\" : { \"b\" : 1, \"c\" : 2 }, \"_id\" : 0 }", tojson(t.findOne()) );
 
 t.drop();
 t.save( { _id:0, '1':{}, '01':{} } );
 t.update( {}, { $set:{ '1.b':1, '01.c':2 } } );
-assert.eq( { '01':{ c:2 }, '1':{ b:1 }, _id:0 }, t.findOne() );
+assert.eq( "{ \"01\" : { \"c\" : 2 }, \"1\" : { \"b\" : 1 }, \"_id\" : 0 }", tojson(t.findOne()) );
+
diff --git a/src/mongo/db/ops/query.cpp b/src/mongo/db/ops/query.cpp
@@ -234,13 +234,14 @@ namespace mongo {
     MatchCountingExplainStrategy::MatchCountingExplainStrategy
     ( const ExplainQueryInfo::AncillaryInfo &ancillaryInfo ) :
     ExplainRecordingStrategy( ancillaryInfo ),
-    _matches() {
+    _orderedMatches() {
     }
     
-    void MatchCountingExplainStrategy::noteIterate( bool match, bool loadedObject, bool chunkSkip ) {
-        _noteIterate( match, loadedObject, chunkSkip );
-        if ( match ) {
-            ++_matches;
+    void MatchCountingExplainStrategy::noteIterate( bool match, bool orderedMatch,
+                                                   bool loadedObject, bool chunkSkip ) {
+        _noteIterate( match, orderedMatch, loadedObject, chunkSkip );
+        if ( orderedMatch ) {
+            ++_orderedMatches;
         }
     }
     
@@ -256,7 +257,8 @@ namespace mongo {
         _explainInfo->notePlan( *_cursor, scanAndOrder, indexOnly );
     }
 
-    void SimpleCursorExplainStrategy::_noteIterate( bool match, bool loadedObject, bool chunkSkip ) {
+    void SimpleCursorExplainStrategy::_noteIterate( bool match, bool orderedMatch,
+                                                   bool loadedObject, bool chunkSkip ) {
         _explainInfo->noteIterate( match, loadedObject, chunkSkip, *_cursor );
     }
 
@@ -276,9 +278,11 @@ namespace mongo {
     _cursor( cursor ) {
     }
     
-    void QueryOptimizerCursorExplainStrategy::_noteIterate( bool match, bool loadedObject,
-                                                          bool chunkSkip ) {
-        _cursor->noteIterate( match, loadedObject, chunkSkip );
+    void QueryOptimizerCursorExplainStrategy::_noteIterate( bool match, bool orderedMatch,
+                                                           bool loadedObject, bool chunkSkip ) {
+        // Note ordered matches only; if an unordered plan is selected, the explain result will
+        // be updated with reviseN().
+        _cursor->noteIterate( orderedMatch, loadedObject, chunkSkip );
     }
 
     shared_ptr<ExplainQueryInfo> QueryOptimizerCursorExplainStrategy::_doneQueryInfo() {
@@ -336,22 +340,22 @@ namespace mongo {
     _bufferedMatches() {
     }
     
-    bool OrderedBuildStrategy::handleMatch() {
+    bool OrderedBuildStrategy::handleMatch( bool &orderedMatch ) {
         DiskLoc loc = _cursor->currLoc();
         if ( _cursor->getsetdup( loc ) ) {
-            return false;
+            return orderedMatch = false;
         }
         if ( _skip > 0 ) {
             --_skip;
-            return false;
+            return orderedMatch = false;
         }
         // Explain does not obey soft limits, so matches should not be buffered.
         if ( !_parsedQuery.isExplain() ) {
             fillQueryResultFromObj( _buf, _parsedQuery.getFields(), current( true ),
                                    ( _parsedQuery.showDiskLoc() ? &loc : 0 ) );
             ++_bufferedMatches;
         }
-        return true;
+        return orderedMatch = true;
     }
     
     ReorderBuildStrategy::ReorderBuildStrategy( const ParsedQuery &parsedQuery,
@@ -363,17 +367,18 @@ namespace mongo {
     _bufferedMatches() {
     }
 
-    bool ReorderBuildStrategy::handleMatch() {
+    bool ReorderBuildStrategy::handleMatch( bool &orderedMatch ) {
+        orderedMatch = false;
         if ( _cursor->getsetdup( _cursor->currLoc() ) ) {
             return false;
         }
-        return _handleMatchNoDedup();
+        _handleMatchNoDedup();
+        return true;
     }
     
-    bool ReorderBuildStrategy::_handleMatchNoDedup() {
+    void ReorderBuildStrategy::_handleMatchNoDedup() {
         DiskLoc loc = _cursor->currLoc();
         _scanAndOrder->add( current( false ), _parsedQuery.showDiskLoc() ? &loc : 0 );
-        return false;
     }
 
     int ReorderBuildStrategy::rewriteMatches() {
@@ -412,18 +417,18 @@ namespace mongo {
     _reorderedMatches() {
     }
     
-    bool HybridBuildStrategy::handleMatch() {
+    bool HybridBuildStrategy::handleMatch( bool &orderedMatch ) {
         if ( !_queryOptimizerCursor->currentPlanScanAndOrderRequired() ) {
-            return _orderedBuild.handleMatch();
+            return _orderedBuild.handleMatch( orderedMatch );
         }
-        handleReorderMatch();
-        return false;
+        orderedMatch = false;
+        return handleReorderMatch();
     }
     
-    void HybridBuildStrategy::handleReorderMatch() {
+    bool HybridBuildStrategy::handleReorderMatch() {
         DiskLoc loc = _cursor->currLoc();
         if ( _scanAndOrderDups.getsetdup( loc ) ) {
-            return;
+            return false;
         }
         try {
             _reorderBuild._handleMatchNoDedup();
@@ -435,11 +440,12 @@ namespace mongo {
                 }
                 else if ( _queryOptimizerCursor->runningInitialInOrderPlan() ) {
                     _queryOptimizerCursor->abortOutOfOrderPlans();
-                    return;
+                    return true;
                 }
             }
             throw;
-        }            
+        }
+        return true;
     }
     
     int HybridBuildStrategy::rewriteMatches() {
@@ -482,9 +488,10 @@ namespace mongo {
         if ( !chunkMatches() ) {
             return false;
         }
-        bool orderedMatch = _builder->handleMatch();
-        _explain->noteIterate( orderedMatch, true, false );
-        return true;
+        bool orderedMatch = false;
+        bool match = _builder->handleMatch( orderedMatch );
+        _explain->noteIterate( match, orderedMatch, true, false );
+        return match;
     }
 
     void QueryResponseBuilder::noteYield() {
@@ -497,7 +504,7 @@ namespace mongo {
 
     bool QueryResponseBuilder::enoughTotalResults() const {
         if ( _parsedQuery.isExplain() ) {
-            return _parsedQuery.enoughForExplain( _explain->matches() );
+            return _parsedQuery.enoughForExplain( _explain->orderedMatches() );
         }
         return ( _parsedQuery.enough( _builder->bufferedMatches() ) ||
                 _buf.len() >= MaxBytesToReturnToClientAtOnce );
@@ -584,7 +591,7 @@ namespace mongo {
         if ( _cursor->currentMatches( &details ) ) {
             return true;
         }
-        _explain->noteIterate( false, details._loadedObject, false );
+        _explain->noteIterate( false, false, details._loadedObject, false );
         return false;
     }
 
@@ -596,7 +603,7 @@ namespace mongo {
         if ( _chunkManager->belongsToMe( _cursor->current() ) ) {
             return true;
         }
-        _explain->noteIterate( false, true, true );
+        _explain->noteIterate( false, false, true, true );
         return false;
     }
     
diff --git a/src/mongo/db/ops/query.h b/src/mongo/db/ops/query.h
diff --git a/src/mongo/s/d_migrate.cpp b/src/mongo/s/d_migrate.cpp

Original file line number	Diff line number	Diff line change
`@@ -234,13 +234,14 @@ namespace mongo {`
`234`	`234`	`MatchCountingExplainStrategy::MatchCountingExplainStrategy`
`235`	`235`	`( const ExplainQueryInfo::AncillaryInfo &ancillaryInfo ) :`
`236`	`236`	`ExplainRecordingStrategy( ancillaryInfo ),`
`237`		`- _matches() {`
	`237`	`+ _orderedMatches() {`
`238`	`238`	`}`
`239`	`239`
`240`		`- void MatchCountingExplainStrategy::noteIterate( bool match, bool loadedObject, bool chunkSkip ) {`
`241`		`- _noteIterate( match, loadedObject, chunkSkip );`
`242`		`- if ( match ) {`
`243`		`- ++_matches;`
	`240`	`+ void MatchCountingExplainStrategy::noteIterate( bool match, bool orderedMatch,`
	`241`	`+ bool loadedObject, bool chunkSkip ) {`
	`242`	`+ _noteIterate( match, orderedMatch, loadedObject, chunkSkip );`
	`243`	`+ if ( orderedMatch ) {`
	`244`	`+ ++_orderedMatches;`
`244`	`245`	`}`
`245`	`246`	`}`
`246`	`247`
`@@ -256,7 +257,8 @@ namespace mongo {`
`256`	`257`	`_explainInfo->notePlan( *_cursor, scanAndOrder, indexOnly );`
`257`	`258`	`}`
`258`	`259`
`259`		`- void SimpleCursorExplainStrategy::_noteIterate( bool match, bool loadedObject, bool chunkSkip ) {`
	`260`	`+ void SimpleCursorExplainStrategy::_noteIterate( bool match, bool orderedMatch,`
	`261`	`+ bool loadedObject, bool chunkSkip ) {`
`260`	`262`	`_explainInfo->noteIterate( match, loadedObject, chunkSkip, *_cursor );`
`261`	`263`	`}`
`262`	`264`
`@@ -276,9 +278,11 @@ namespace mongo {`
`276`	`278`	`_cursor( cursor ) {`
`277`	`279`	`}`
`278`	`280`
`279`		`- void QueryOptimizerCursorExplainStrategy::_noteIterate( bool match, bool loadedObject,`
`280`		`- bool chunkSkip ) {`
`281`		`- _cursor->noteIterate( match, loadedObject, chunkSkip );`
	`281`	`+ void QueryOptimizerCursorExplainStrategy::_noteIterate( bool match, bool orderedMatch,`
	`282`	`+ bool loadedObject, bool chunkSkip ) {`
	`283`	`+ // Note ordered matches only; if an unordered plan is selected, the explain result will`
	`284`	`+ // be updated with reviseN().`
	`285`	`+ _cursor->noteIterate( orderedMatch, loadedObject, chunkSkip );`
`282`	`286`	`}`
`283`	`287`
`284`	`288`	`shared_ptr<ExplainQueryInfo> QueryOptimizerCursorExplainStrategy::_doneQueryInfo() {`
`@@ -336,22 +340,22 @@ namespace mongo {`
`336`	`340`	`_bufferedMatches() {`
`337`	`341`	`}`
`338`	`342`
`339`		`- bool OrderedBuildStrategy::handleMatch() {`
	`343`	`+ bool OrderedBuildStrategy::handleMatch( bool &orderedMatch ) {`
`340`	`344`	`DiskLoc loc = _cursor->currLoc();`
`341`	`345`	`if ( _cursor->getsetdup( loc ) ) {`
`342`		`- return false;`
	`346`	`+ return orderedMatch = false;`
`343`	`347`	`}`
`344`	`348`	`if ( _skip > 0 ) {`
`345`	`349`	`--_skip;`
`346`		`- return false;`
	`350`	`+ return orderedMatch = false;`
`347`	`351`	`}`
`348`	`352`	`// Explain does not obey soft limits, so matches should not be buffered.`
`349`	`353`	`if ( !_parsedQuery.isExplain() ) {`
`350`	`354`	`fillQueryResultFromObj( _buf, _parsedQuery.getFields(), current( true ),`
`351`	`355`	`( _parsedQuery.showDiskLoc() ? &loc : 0 ) );`
`352`	`356`	`++_bufferedMatches;`
`353`	`357`	`}`
`354`		`- return true;`
	`358`	`+ return orderedMatch = true;`
`355`	`359`	`}`
`356`	`360`
`357`	`361`	`ReorderBuildStrategy::ReorderBuildStrategy( const ParsedQuery &parsedQuery,`
`@@ -363,17 +367,18 @@ namespace mongo {`
`363`	`367`	`_bufferedMatches() {`
`364`	`368`	`}`
`365`	`369`
`366`		`- bool ReorderBuildStrategy::handleMatch() {`
	`370`	`+ bool ReorderBuildStrategy::handleMatch( bool &orderedMatch ) {`
	`371`	`+ orderedMatch = false;`
`367`	`372`	`if ( _cursor->getsetdup( _cursor->currLoc() ) ) {`
`368`	`373`	`return false;`
`369`	`374`	`}`
`370`		`- return _handleMatchNoDedup();`
	`375`	`+ _handleMatchNoDedup();`
	`376`	`+ return true;`
`371`	`377`	`}`
`372`	`378`
`373`		`- bool ReorderBuildStrategy::_handleMatchNoDedup() {`
	`379`	`+ void ReorderBuildStrategy::_handleMatchNoDedup() {`
`374`	`380`	`DiskLoc loc = _cursor->currLoc();`
`375`	`381`	`_scanAndOrder->add( current( false ), _parsedQuery.showDiskLoc() ? &loc : 0 );`
`376`		`- return false;`
`377`	`382`	`}`
`378`	`383`
`379`	`384`	`int ReorderBuildStrategy::rewriteMatches() {`
`@@ -412,18 +417,18 @@ namespace mongo {`
`412`	`417`	`_reorderedMatches() {`
`413`	`418`	`}`
`414`	`419`
`415`		`- bool HybridBuildStrategy::handleMatch() {`
	`420`	`+ bool HybridBuildStrategy::handleMatch( bool &orderedMatch ) {`
`416`	`421`	`if ( !_queryOptimizerCursor->currentPlanScanAndOrderRequired() ) {`
`417`		`- return _orderedBuild.handleMatch();`
	`422`	`+ return _orderedBuild.handleMatch( orderedMatch );`
`418`	`423`	`}`
`419`		`- handleReorderMatch();`
`420`		`- return false;`
	`424`	`+ orderedMatch = false;`
	`425`	`+ return handleReorderMatch();`
`421`	`426`	`}`
`422`	`427`
`423`		`- void HybridBuildStrategy::handleReorderMatch() {`
	`428`	`+ bool HybridBuildStrategy::handleReorderMatch() {`
`424`	`429`	`DiskLoc loc = _cursor->currLoc();`
`425`	`430`	`if ( _scanAndOrderDups.getsetdup( loc ) ) {`
`426`		`- return;`
	`431`	`+ return false;`
`427`	`432`	`}`
`428`	`433`	`try {`
`429`	`434`	`_reorderBuild._handleMatchNoDedup();`
`@@ -435,11 +440,12 @@ namespace mongo {`
`435`	`440`	`}`
`436`	`441`	`else if ( _queryOptimizerCursor->runningInitialInOrderPlan() ) {`
`437`	`442`	`_queryOptimizerCursor->abortOutOfOrderPlans();`
`438`		`- return;`
	`443`	`+ return true;`
`439`	`444`	`}`
`440`	`445`	`}`
`441`	`446`	`throw;`
`442`		`- }`
	`447`	`+ }`
	`448`	`+ return true;`
`443`	`449`	`}`
`444`	`450`
`445`	`451`	`int HybridBuildStrategy::rewriteMatches() {`
`@@ -482,9 +488,10 @@ namespace mongo {`
`482`	`488`	`if ( !chunkMatches() ) {`
`483`	`489`	`return false;`
`484`	`490`	`}`
`485`		`- bool orderedMatch = _builder->handleMatch();`
`486`		`- _explain->noteIterate( orderedMatch, true, false );`
`487`		`- return true;`
	`491`	`+ bool orderedMatch = false;`
	`492`	`+ bool match = _builder->handleMatch( orderedMatch );`
	`493`	`+ _explain->noteIterate( match, orderedMatch, true, false );`
	`494`	`+ return match;`
`488`	`495`	`}`
`489`	`496`
`490`	`497`	`void QueryResponseBuilder::noteYield() {`
`@@ -497,7 +504,7 @@ namespace mongo {`
`497`	`504`
`498`	`505`	`bool QueryResponseBuilder::enoughTotalResults() const {`
`499`	`506`	`if ( _parsedQuery.isExplain() ) {`
`500`		`- return _parsedQuery.enoughForExplain( _explain->matches() );`
	`507`	`+ return _parsedQuery.enoughForExplain( _explain->orderedMatches() );`
`501`	`508`	`}`
`502`	`509`	`return ( _parsedQuery.enough( _builder->bufferedMatches() ) \|\|`
`503`	`510`	`_buf.len() >= MaxBytesToReturnToClientAtOnce );`
`@@ -584,7 +591,7 @@ namespace mongo {`
`584`	`591`	`if ( _cursor->currentMatches( &details ) ) {`
`585`	`592`	`return true;`
`586`	`593`	`}`
`587`		`- _explain->noteIterate( false, details._loadedObject, false );`
	`594`	`+ _explain->noteIterate( false, false, details._loadedObject, false );`
`588`	`595`	`return false;`
`589`	`596`	`}`
`590`	`597`
`@@ -596,7 +603,7 @@ namespace mongo {`
`596`	`603`	`if ( _chunkManager->belongsToMe( _cursor->current() ) ) {`
`597`	`604`	`return true;`
`598`	`605`	`}`
`599`		`- _explain->noteIterate( false, true, true );`
	`606`	`+ _explain->noteIterate( false, false, true, true );`
`600`	`607`	`return false;`
`601`	`608`	`}`
`602`	`609`