SERVER-17364 Unify handling of child stages into PlanStage base class

This is prep for adding more methods that need to propagate to children.

Author: RedBeard0531

src/mongo/db/exec/SConscript

@@ -58,6 +58,7 @@ env.Library(
         "oplogstart.cpp",
         "or.cpp",
         "pipeline_proxy.cpp",
+        "plan_stage.cpp",
         "projection.cpp",
         "projection_exec.cpp",
         "queued_data_stage.cpp",

src/mongo/db/exec/and_hash.cpp

@@ -55,31 +55,25 @@ const size_t AndHashStage::kLookAheadWorks = 10;
 const char* AndHashStage::kStageType = "AND_HASH";
 
 AndHashStage::AndHashStage(WorkingSet* ws, const Collection* collection)
-    : _collection(collection),
+    : PlanStage(kStageType),
+      _collection(collection),
       _ws(ws),
       _hashingChildren(true),
       _currentChild(0),
-      _commonStats(kStageType),
       _memUsage(0),
       _maxMemUsage(kDefaultMaxMemUsageBytes) {}
 
 AndHashStage::AndHashStage(WorkingSet* ws, const Collection* collection, size_t maxMemUsage)
-    : _collection(collection),
+    : PlanStage(kStageType),
+      _collection(collection),
       _ws(ws),
       _hashingChildren(true),
       _currentChild(0),
-      _commonStats(kStageType),
       _memUsage(0),
       _maxMemUsage(maxMemUsage) {}
 
-AndHashStage::~AndHashStage() {
-    for (size_t i = 0; i < _children.size(); ++i) {
-        delete _children[i];
-    }
-}
-
 void AndHashStage::addChild(PlanStage* child) {
-    _children.push_back(child);
+    _children.emplace_back(child);
 }
 
 size_t AndHashStage::getMemUsage() const {
@@ -137,7 +131,7 @@ PlanStage::StageState AndHashStage::work(WorkingSetID* out) {
         // a result.  If it's EOF this whole stage will be EOF.  If it produces a
         // result we cache it for later.
         for (size_t i = 0; i < _children.size(); ++i) {
-            PlanStage* child = _children[i];
+            auto& child = _children[i];
             for (size_t j = 0; j < kLookAheadWorks; ++j) {
                 StageState childStatus = child->work(&_lookAheadResults[i]);
 
@@ -428,33 +422,12 @@ PlanStage::StageState AndHashStage::hashOtherChildren(WorkingSetID* out) {
     }
 }
 
-void AndHashStage::saveState() {
-    ++_commonStats.yields;
-
-    for (size_t i = 0; i < _children.size(); ++i) {
-        _children[i]->saveState();
-    }
-}
-
-void AndHashStage::restoreState(OperationContext* opCtx) {
-    ++_commonStats.unyields;
-
-    for (size_t i = 0; i < _children.size(); ++i) {
-        _children[i]->restoreState(opCtx);
-    }
-}
-
-void AndHashStage::invalidate(OperationContext* txn, const RecordId& dl, InvalidationType type) {
-    ++_commonStats.invalidates;
-
+void AndHashStage::doInvalidate(OperationContext* txn, const RecordId& dl, InvalidationType type) {
+    // TODO remove this since calling isEOF is illegal inside of doInvalidate().
     if (isEOF()) {
         return;
     }
 
-    for (size_t i = 0; i < _children.size(); ++i) {
-        _children[i]->invalidate(txn, dl, type);
-    }
-
     // Invalidation can happen to our warmup results.  If that occurs just
     // flag it and forget about it.
     for (size_t i = 0; i < _lookAheadResults.size(); ++i) {
@@ -500,10 +473,6 @@ void AndHashStage::invalidate(OperationContext* txn, const RecordId& dl, Invalid
     }
 }
 
-vector<PlanStage*> AndHashStage::getChildren() const {
-    return _children;
-}
-
 unique_ptr<PlanStageStats> AndHashStage::getStats() {
     _commonStats.isEOF = isEOF();
 
@@ -519,10 +488,6 @@ unique_ptr<PlanStageStats> AndHashStage::getStats() {
     return ret;
 }
 
-const CommonStats* AndHashStage::getCommonStats() const {
-    return &_commonStats;
-}
-
 const SpecificStats* AndHashStage::getSpecificStats() const {
     return &_specificStats;
 }

src/mongo/db/exec/and_hash.h

@@ -58,8 +58,6 @@ class AndHashStage : public PlanStage {
      */
     AndHashStage(WorkingSet* ws, const Collection* collection, size_t maxMemUsage);
 
-    virtual ~AndHashStage();
-
     void addChild(PlanStage* child);
 
     /**
@@ -71,20 +69,14 @@ class AndHashStage : public PlanStage {
     virtual StageState work(WorkingSetID* out);
     virtual bool isEOF();
 
-    virtual void saveState();
-    virtual void restoreState(OperationContext* opCtx);
-    virtual void invalidate(OperationContext* txn, const RecordId& dl, InvalidationType type);
-
-    virtual std::vector<PlanStage*> getChildren() const;
+    virtual void doInvalidate(OperationContext* txn, const RecordId& dl, InvalidationType type);
 
     virtual StageType stageType() const {
         return STAGE_AND_HASH;
     }
 
     virtual std::unique_ptr<PlanStageStats> getStats();
 
-    virtual const CommonStats* getCommonStats() const;
-
     virtual const SpecificStats* getSpecificStats() const;
 
     static const char* kStageType;
@@ -102,9 +94,6 @@ class AndHashStage : public PlanStage {
     // Not owned by us.
     WorkingSet* _ws;
 
-    // The stages we read from.  Owned by us.
-    std::vector<PlanStage*> _children;
-
     // We want to see if any of our children are EOF immediately.  This requires working them a
     // few times to see if they hit EOF or if they produce a result.  If they produce a result,
     // we place that result here.
@@ -127,7 +116,6 @@ class AndHashStage : public PlanStage {
     size_t _currentChild;
 
     // Stats
-    CommonStats _commonStats;
     AndHashStats _specificStats;
 
     // The usage in bytes of all buffered data that we're holding.

src/mongo/db/exec/and_sorted.cpp

@@ -45,21 +45,16 @@ using stdx::make_unique;
 const char* AndSortedStage::kStageType = "AND_SORTED";
 
 AndSortedStage::AndSortedStage(WorkingSet* ws, const Collection* collection)
-    : _collection(collection),
+    : PlanStage(kStageType),
+      _collection(collection),
       _ws(ws),
       _targetNode(numeric_limits<size_t>::max()),
       _targetId(WorkingSet::INVALID_ID),
-      _isEOF(false),
-      _commonStats(kStageType) {}
+      _isEOF(false) {}
 
-AndSortedStage::~AndSortedStage() {
-    for (size_t i = 0; i < _children.size(); ++i) {
-        delete _children[i];
-    }
-}
 
 void AndSortedStage::addChild(PlanStage* child) {
-    _children.push_back(child);
+    _children.emplace_back(child);
 }
 
 bool AndSortedStage::isEOF() {
@@ -160,7 +155,7 @@ PlanStage::StageState AndSortedStage::moveTowardTargetLoc(WorkingSetID* out) {
 
     // We have nodes that haven't hit _targetLoc yet.
     size_t workingChildNumber = _workingTowardRep.front();
-    PlanStage* next = _children[workingChildNumber];
+    auto& next = _children[workingChildNumber];
     WorkingSetID id = WorkingSet::INVALID_ID;
     StageState state = next->work(&id);
 
@@ -253,33 +248,15 @@ PlanStage::StageState AndSortedStage::moveTowardTargetLoc(WorkingSetID* out) {
     }
 }
 
-void AndSortedStage::saveState() {
-    ++_commonStats.yields;
-
-    for (size_t i = 0; i < _children.size(); ++i) {
-        _children[i]->saveState();
-    }
-}
-
-void AndSortedStage::restoreState(OperationContext* opCtx) {
-    ++_commonStats.unyields;
-
-    for (size_t i = 0; i < _children.size(); ++i) {
-        _children[i]->restoreState(opCtx);
-    }
-}
-
-void AndSortedStage::invalidate(OperationContext* txn, const RecordId& dl, InvalidationType type) {
-    ++_commonStats.invalidates;
 
+void AndSortedStage::doInvalidate(OperationContext* txn,
+                                  const RecordId& dl,
+                                  InvalidationType type) {
+    // TODO remove this since calling isEOF is illegal inside of doInvalidate().
     if (isEOF()) {
         return;
     }
 
-    for (size_t i = 0; i < _children.size(); ++i) {
-        _children[i]->invalidate(txn, dl, type);
-    }
-
     if (dl == _targetLoc) {
         // We're in the middle of moving children forward until they hit _targetLoc, which is no
         // longer a valid target.  If it's a deletion we can't AND it with anything, if it's a
@@ -298,10 +275,6 @@ void AndSortedStage::invalidate(OperationContext* txn, const RecordId& dl, Inval
     }
 }
 
-vector<PlanStage*> AndSortedStage::getChildren() const {
-    return _children;
-}
-
 unique_ptr<PlanStageStats> AndSortedStage::getStats() {
     _commonStats.isEOF = isEOF();
 
@@ -314,10 +287,6 @@ unique_ptr<PlanStageStats> AndSortedStage::getStats() {
     return ret;
 }
 
-const CommonStats* AndSortedStage::getCommonStats() const {
-    return &_commonStats;
-}
-
 const SpecificStats* AndSortedStage::getSpecificStats() const {
     return &_specificStats;
 }

src/mongo/db/exec/and_sorted.h

@@ -54,27 +54,20 @@ namespace mongo {
 class AndSortedStage : public PlanStage {
 public:
     AndSortedStage(WorkingSet* ws, const Collection* collection);
-    virtual ~AndSortedStage();
 
     void addChild(PlanStage* child);
 
     virtual StageState work(WorkingSetID* out);
     virtual bool isEOF();
 
-    virtual void saveState();
-    virtual void restoreState(OperationContext* opCtx);
-    virtual void invalidate(OperationContext* txn, const RecordId& dl, InvalidationType type);
-
-    virtual std::vector<PlanStage*> getChildren() const;
+    virtual void doInvalidate(OperationContext* txn, const RecordId& dl, InvalidationType type);
 
     virtual StageType stageType() const {
         return STAGE_AND_SORTED;
     }
 
     virtual std::unique_ptr<PlanStageStats> getStats();
 
-    virtual const CommonStats* getCommonStats() const;
-
     virtual const SpecificStats* getSpecificStats() const;
 
     static const char* kStageType;
@@ -93,9 +86,6 @@ class AndSortedStage : public PlanStage {
     // Not owned by us.
     WorkingSet* _ws;
 
-    // Owned by us.
-    std::vector<PlanStage*> _children;
-
     // The current node we're AND-ing against.
     size_t _targetNode;
     RecordId _targetLoc;
@@ -110,7 +100,6 @@ class AndSortedStage : public PlanStage {
     bool _isEOF;
 
     // Stats
-    CommonStats _commonStats;
     AndSortedStats _specificStats;
 };