diff --git a/arangod/Aql/ExecutionBlock.cpp b/arangod/Aql/ExecutionBlock.cpp index 8f61d52603..c0ee66120d 100644 --- a/arangod/Aql/ExecutionBlock.cpp +++ b/arangod/Aql/ExecutionBlock.cpp @@ -43,7 +43,7 @@ int ExecutionBlock::bind (std::map* params) { } //////////////////////////////////////////////////////////////////////////////// -/// @brief functionality to walk an execution plan recursively +/// @brief functionality to walk an execution block recursively //////////////////////////////////////////////////////////////////////////////// void ExecutionBlock::walk (WalkerWorker* worker) { @@ -60,7 +60,7 @@ void ExecutionBlock::walk (WalkerWorker* worker) { (*it)->walk(worker); } // Now handle a subquery: - if (_exePlan->getType() == ExecutionPlan::SUBQUERY) { + if (_exePlan->getType() == ExecutionNode::SUBQUERY) { // auto p = static_cast(this); if (worker->enterSubquery(this, nullptr)) { ; // p->_subquery // p->_subquery->walk(worker); @@ -75,26 +75,26 @@ void ExecutionBlock::walk (WalkerWorker* worker) { // --SECTION-- factory for instanciation of plans // ----------------------------------------------------------------------------- -ExecutionBlock* ExecutionBlock::instanciatePlan (ExecutionPlan const* ep) { +ExecutionBlock* ExecutionBlock::instanciatePlan (ExecutionNode const* ep) { ExecutionBlock* eb; switch (ep->getType()) { - case ExecutionPlan::SINGLETON: { - eb = new SingletonBlock(static_cast(ep)); + case ExecutionNode::SINGLETON: { + eb = new SingletonBlock(static_cast(ep)); break; } - case ExecutionPlan::ENUMERATE_COLLECTION: { - eb = new EnumerateCollectionBlock(static_cast(ep)); + case ExecutionNode::ENUMERATE_COLLECTION: { + eb = new EnumerateCollectionBlock(static_cast(ep)); break; } - case ExecutionPlan::ROOT: { - eb = new RootBlock(static_cast(ep)); + case ExecutionNode::ROOT: { + eb = new RootBlock(static_cast(ep)); break; } default: { THROW_ARANGO_EXCEPTION(TRI_ERROR_NOT_IMPLEMENTED); } } - vector deps = ep->getDependencies(); + vector deps = ep->getDependencies(); for (auto it = deps.begin(); it != deps.end();++it) { eb->addDependency(instanciatePlan(*it)); } diff --git a/arangod/Aql/ExecutionBlock.h b/arangod/Aql/ExecutionBlock.h index 273206533d..f00f90025e 100644 --- a/arangod/Aql/ExecutionBlock.h +++ b/arangod/Aql/ExecutionBlock.h @@ -48,7 +48,7 @@ namespace triagens { class ExecutionBlock { public: - ExecutionBlock (ExecutionPlan const* ep) + ExecutionBlock (ExecutionNode const* ep) : _exePlan(ep), _done(false), _depth(0) { } virtual ~ExecutionBlock (); @@ -100,7 +100,7 @@ namespace triagens { } //////////////////////////////////////////////////////////////////////////////// -/// @brief functionality to walk an execution plan recursively +/// @brief functionality to walk an execution block recursively //////////////////////////////////////////////////////////////////////////////// class WalkerWorker { @@ -187,49 +187,49 @@ namespace triagens { } virtual void after (ExecutionBlock *eb) { - switch (eb->getPlan()->getType()) { - case ExecutionPlan::ENUMERATE_COLLECTION: { + switch (eb->getPlanNode()->getType()) { + case ExecutionNode::ENUMERATE_COLLECTION: { depth++; nrVarsHere.push_back(1); nrVars.push_back(1 + nrVars.back()); - auto ep = static_cast(eb->getPlan()); + auto ep = static_cast(eb->getPlanNode()); varInfo.insert(make_pair(ep->_outVariable->id, VarInfo(depth, totalNrVars))); totalNrVars++; break; } - case ExecutionPlan::ENUMERATE_LIST: { + case ExecutionNode::ENUMERATE_LIST: { depth++; nrVarsHere.push_back(1); nrVars.push_back(1 + nrVars.back()); - auto ep = static_cast(eb->getPlan()); + auto ep = static_cast(eb->getPlanNode()); varInfo.insert(make_pair(ep->_outVariable->id, VarInfo(depth, totalNrVars))); totalNrVars++; break; } - case ExecutionPlan::CALCULATION: { + case ExecutionNode::CALCULATION: { nrVarsHere[depth]++; nrVars[depth]++; - auto ep = static_cast(eb->getPlan()); + auto ep = static_cast(eb->getPlanNode()); varInfo.insert(make_pair(ep->_outVariable->id, VarInfo(depth, totalNrVars))); totalNrVars++; break; } - case ExecutionPlan::PROJECTION: { + case ExecutionNode::PROJECTION: { nrVarsHere[depth]++; nrVars[depth]++; - auto ep = static_cast(eb->getPlan()); + auto ep = static_cast(eb->getPlanNode()); varInfo.insert(make_pair(ep->_outVariable->id, VarInfo(depth, totalNrVars))); totalNrVars++; break; } - case ExecutionPlan::SUBQUERY: { + case ExecutionNode::SUBQUERY: { nrVarsHere[depth]++; nrVars[depth]++; - auto ep = static_cast(eb->getPlan()); + auto ep = static_cast(eb->getPlanNode()); varInfo.insert(make_pair(ep->_outVariable->id, VarInfo(depth, totalNrVars))); totalNrVars++; @@ -441,16 +441,16 @@ namespace triagens { return 0; } - ExecutionPlan const* getPlan () { + ExecutionNode const* getPlanNode () { return _exePlan; } //////////////////////////////////////////////////////////////////////////////// -/// @brief our corresponding ExecutionPlan node +/// @brief our corresponding ExecutionNode node //////////////////////////////////////////////////////////////////////////////// protected: - ExecutionPlan const* _exePlan; + ExecutionNode const* _exePlan; //////////////////////////////////////////////////////////////////////////////// /// @brief our dependent nodes @@ -489,11 +489,11 @@ namespace triagens { std::shared_ptr _varOverview; //////////////////////////////////////////////////////////////////////////////// -/// @brief a static factory for ExecutionBlocks from ExecutionPlans +/// @brief a static factory for ExecutionBlocks from ExecutionNodes //////////////////////////////////////////////////////////////////////////////// public: - static ExecutionBlock* instanciatePlan (ExecutionPlan const* ep); + static ExecutionBlock* instanciatePlan (ExecutionNode const* ep); }; @@ -509,7 +509,7 @@ namespace triagens { /// @brief constructor //////////////////////////////////////////////////////////////////////////////// - SingletonBlock (SingletonPlan const* ep) + SingletonBlock (SingletonNode const* ep) : ExecutionBlock(ep) { } @@ -588,7 +588,7 @@ namespace triagens { /// @brief constructor //////////////////////////////////////////////////////////////////////////////// - EnumerateCollectionBlock (EnumerateCollectionPlan const* ep) + EnumerateCollectionBlock (EnumerateCollectionNode const* ep) : ExecutionBlock(ep), _posInAllDocs(0) { } @@ -618,7 +618,7 @@ namespace triagens { return res; } - auto p = reinterpret_cast(_exePlan); + auto p = reinterpret_cast(_exePlan); V8ReadTransaction trx(p->_vocbase, p->_collname); @@ -793,7 +793,7 @@ namespace triagens { public: - RootBlock (RootPlan const* ep) + RootBlock (RootNode const* ep) : ExecutionBlock(ep) { } @@ -811,7 +811,7 @@ namespace triagens { // Let's steal the actual result and throw away the vars: AqlItemBlock* stripped = new AqlItemBlock(1, 1); - auto ep = static_cast(getPlan()); + auto ep = static_cast(getPlanNode()); auto it = _varOverview->varInfo.find(ep->_inVariable->id); TRI_ASSERT(it != _varOverview->varInfo.end()); unsigned int index = it->second.index; @@ -829,7 +829,7 @@ namespace triagens { } // Let's steal the actual result and throw away the vars: - auto ep = static_cast(getPlan()); + auto ep = static_cast(getPlanNode()); auto it = _varOverview->varInfo.find(ep->_inVariable->id); TRI_ASSERT(it != _varOverview->varInfo.end()); unsigned int index = it->second.index; diff --git a/arangod/Aql/ExecutionPlan.cpp b/arangod/Aql/ExecutionPlan.cpp index 259420b4e1..dbaf24028c 100644 --- a/arangod/Aql/ExecutionPlan.cpp +++ b/arangod/Aql/ExecutionPlan.cpp @@ -31,15 +31,15 @@ using namespace triagens::basics; using namespace triagens::aql; // ----------------------------------------------------------------------------- -// --SECTION-- methods of ExecutionPlan +// --SECTION-- methods of ExecutionNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief toJson, export an ExecutionPlan to JSON +/// @brief toJson, export an ExecutionNode to JSON //////////////////////////////////////////////////////////////////////////////// -Json ExecutionPlan::toJson (TRI_memory_zone_t* zone) { - std::map indexTab; +Json ExecutionNode::toJson (TRI_memory_zone_t* zone) { + std::map indexTab; Json json; Json nodes; try { @@ -58,7 +58,7 @@ Json ExecutionPlan::toJson (TRI_memory_zone_t* zone) { /// @brief toJsonHelper, for a generic node //////////////////////////////////////////////////////////////////////////////// -Json ExecutionPlan::toJsonHelperGeneric (std::map& indexTab, +Json ExecutionNode::toJsonHelperGeneric (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone) { auto iter = indexTab.find(this); @@ -98,7 +98,7 @@ static void someSpaces (std::string& st, int nr) { } } -void ExecutionPlan::appendAsString (std::string& st, int indent) { +void ExecutionNode::appendAsString (std::string& st, int indent) { someSpaces(st, indent); st.push_back('<'); st.append(getTypeString()); @@ -121,7 +121,7 @@ void ExecutionPlan::appendAsString (std::string& st, int indent) { /// @brief functionality to walk an execution plan recursively //////////////////////////////////////////////////////////////////////////////// -void ExecutionPlan::walk (WalkerWorker& worker) { +void ExecutionNode::walk (WalkerWorker& worker) { worker.before(this); for (auto it = _dependencies.begin(); it != _dependencies.end(); @@ -129,7 +129,7 @@ void ExecutionPlan::walk (WalkerWorker& worker) { (*it)->walk(worker); } if (getType() == SUBQUERY) { - auto p = static_cast(this); + auto p = static_cast(this); worker.enterSubquery(this, p->getSubquery()); p->getSubquery()->walk(worker); worker.leaveSubquery(this, p->getSubquery()); @@ -138,18 +138,18 @@ void ExecutionPlan::walk (WalkerWorker& worker) { } // ----------------------------------------------------------------------------- -// --SECTION-- methods of SingletonPlan +// --SECTION-- methods of SingletonNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief toJson, for SingletonPlan +/// @brief toJson, for SingletonNode //////////////////////////////////////////////////////////////////////////////// -void SingletonPlan::toJsonHelper ( - std::map& indexTab, +void SingletonNode::toJsonHelper ( + std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone) { - Json json(ExecutionPlan::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method + Json json(ExecutionNode::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method if (json.isEmpty()) { return; } @@ -161,17 +161,17 @@ void SingletonPlan::toJsonHelper ( } // ----------------------------------------------------------------------------- -// --SECTION-- methods of EnumerateCollectionPlan +// --SECTION-- methods of EnumerateCollectionNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief toJson, for EnumerateCollectionPlan +/// @brief toJson, for EnumerateCollectionNode //////////////////////////////////////////////////////////////////////////////// -void EnumerateCollectionPlan::toJsonHelper (std::map& indexTab, +void EnumerateCollectionNode::toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone) { - Json json(ExecutionPlan::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method + Json json(ExecutionNode::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method if (json.isEmpty()) { return; } @@ -188,17 +188,17 @@ void EnumerateCollectionPlan::toJsonHelper (std::map& index } // ----------------------------------------------------------------------------- -// --SECTION-- methods of EnumerateListPlan +// --SECTION-- methods of EnumerateListNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief toJson, for EnumerateListPlan +/// @brief toJson, for EnumerateListNode //////////////////////////////////////////////////////////////////////////////// -void EnumerateListPlan::toJsonHelper (std::map& indexTab, +void EnumerateListNode::toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone) { - Json json(ExecutionPlan::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method + Json json(ExecutionNode::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method if (json.isEmpty()) { return; } @@ -212,17 +212,17 @@ void EnumerateListPlan::toJsonHelper (std::map& indexTab, } // ----------------------------------------------------------------------------- -// --SECTION-- methods of LimitPlan +// --SECTION-- methods of LimitNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief toJson, for LimitPlan +/// @brief toJson, for LimitNode //////////////////////////////////////////////////////////////////////////////// -void LimitPlan::toJsonHelper (std::map& indexTab, +void LimitNode::toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone) { - Json json(ExecutionPlan::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method + Json json(ExecutionNode::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method if (json.isEmpty()) { return; } @@ -237,17 +237,17 @@ void LimitPlan::toJsonHelper (std::map& indexTab, } // ----------------------------------------------------------------------------- -// --SECTION-- methods of CalculationPlan +// --SECTION-- methods of CalculationNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief toJson, for CalculationPlan +/// @brief toJson, for CalculationNode //////////////////////////////////////////////////////////////////////////////// -void CalculationPlan::toJsonHelper (std::map& indexTab, +void CalculationNode::toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone) { - Json json(ExecutionPlan::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method + Json json(ExecutionNode::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method if (json.isEmpty()) { return; } @@ -262,17 +262,17 @@ void CalculationPlan::toJsonHelper (std::map& indexTab, } // ----------------------------------------------------------------------------- -// --SECTION-- methods of SubqueryPlan +// --SECTION-- methods of SubqueryNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief toJson, for SubqueryPlan +/// @brief toJson, for SubqueryNode //////////////////////////////////////////////////////////////////////////////// -void SubqueryPlan::toJsonHelper (std::map& indexTab, +void SubqueryNode::toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone) { - Json json(ExecutionPlan::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method + Json json(ExecutionNode::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method if (json.isEmpty()) { return; } @@ -286,17 +286,17 @@ void SubqueryPlan::toJsonHelper (std::map& indexTab, } // ----------------------------------------------------------------------------- -// --SECTION-- methods of ProjectionPlan +// --SECTION-- methods of ProjectionNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief toJson, for ProjectionPlan +/// @brief toJson, for ProjectionNode //////////////////////////////////////////////////////////////////////////////// -void ProjectionPlan::toJsonHelper (std::map& indexTab, +void ProjectionNode::toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone) { - Json json(ExecutionPlan::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method + Json json(ExecutionNode::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method if (json.isEmpty()) { return; } @@ -316,17 +316,17 @@ void ProjectionPlan::toJsonHelper (std::map& indexTab, } // ----------------------------------------------------------------------------- -// --SECTION-- methods of FilterPlan +// --SECTION-- methods of FilterNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief toJson, for FilterPlan +/// @brief toJson, for FilterNode //////////////////////////////////////////////////////////////////////////////// -void FilterPlan::toJsonHelper (std::map& indexTab, +void FilterNode::toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone) { - Json json(ExecutionPlan::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method + Json json(ExecutionNode::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method if (json.isEmpty()) { return; } @@ -340,17 +340,17 @@ void FilterPlan::toJsonHelper (std::map& indexTab, } // ----------------------------------------------------------------------------- -// --SECTION-- methods of SortPlan +// --SECTION-- methods of SortNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief toJson, for SortPlan +/// @brief toJson, for SortNode //////////////////////////////////////////////////////////////////////////////// -void SortPlan::toJsonHelper (std::map& indexTab, +void SortNode::toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone) { - Json json(ExecutionPlan::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method + Json json(ExecutionNode::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method if (json.isEmpty()) { return; } @@ -370,17 +370,17 @@ void SortPlan::toJsonHelper (std::map& indexTab, } // ----------------------------------------------------------------------------- -// --SECTION-- methods of AggregateOnUnSortedPlan +// --SECTION-- methods of AggregateOnUnSortedNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief toJson, for AggregateOnUnSortedPlan +/// @brief toJson, for AggregateOnUnSortedNode //////////////////////////////////////////////////////////////////////////////// -void AggregateOnUnsortedPlan::toJsonHelper (std::map& indexTab, +void AggregateOnUnsortedNode::toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone) { - Json json(ExecutionPlan::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method + Json json(ExecutionNode::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method if (json.isEmpty()) { return; } @@ -406,17 +406,17 @@ void AggregateOnUnsortedPlan::toJsonHelper (std::map& index } // ----------------------------------------------------------------------------- -// --SECTION-- methods of RootPlan +// --SECTION-- methods of RootNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief toJson, for RootPlan +/// @brief toJson, for RootNode //////////////////////////////////////////////////////////////////////////////// -void RootPlan::toJsonHelper (std::map& indexTab, +void RootNode::toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone) { - Json json(ExecutionPlan::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method + Json json(ExecutionNode::toJsonHelperGeneric(indexTab, nodes, zone)); // call base class method if (json.isEmpty()) { return; } diff --git a/arangod/Aql/ExecutionPlan.h b/arangod/Aql/ExecutionPlan.h index 34f5d1ceb7..e90c769c6e 100644 --- a/arangod/Aql/ExecutionPlan.h +++ b/arangod/Aql/ExecutionPlan.h @@ -25,8 +25,8 @@ /// @author Copyright 2014, triagens GmbH, Cologne, Germany //////////////////////////////////////////////////////////////////////////////// -#ifndef ARANGODB_AQL_EXECUTION_PLAN_H -#define ARANGODB_AQL_EXECUTION_PLAN_H 1 +#ifndef ARANGODB_AQL_EXECUTION_Plan_H +#define ARANGODB_AQL_EXECUTION_Plan_H 1 #include @@ -44,10 +44,10 @@ namespace triagens { class ExecutionBlock; //////////////////////////////////////////////////////////////////////////////// -/// @brief class ExecutionPlan, abstract base class of all execution plans +/// @brief class ExecutionNode, abstract base class of all execution Nodes //////////////////////////////////////////////////////////////////////////////// - class ExecutionPlan { + class ExecutionNode { //////////////////////////////////////////////////////////////////////////////// /// @brief node type @@ -93,14 +93,14 @@ namespace triagens { /// @brief default constructor //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan () { + ExecutionNode () { } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor with one dependency //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan (ExecutionPlan* ep) { + ExecutionNode (ExecutionNode* ep) { _dependencies.push_back(ep); } @@ -108,10 +108,7 @@ namespace triagens { /// @brief destructor, free dependencies //////////////////////////////////////////////////////////////////////////////// - virtual ~ExecutionPlan () { - for (auto i = _dependencies.begin(); i != _dependencies.end(); ++i) { - delete *i; - } + virtual ~ExecutionNode () { } //////////////////////////////////////////////////////////////////////////////// @@ -127,14 +124,14 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// virtual std::string getTypeString () const { - return std::string("ExecutionPlan (abstract)"); + return std::string("ExecutionNode (abstract)"); } //////////////////////////////////////////////////////////////////////////////// /// @brief add a dependency //////////////////////////////////////////////////////////////////////////////// - void addDependency (ExecutionPlan* ep) { + void addDependency (ExecutionNode* ep) { _dependencies.push_back(ep); } @@ -142,7 +139,7 @@ namespace triagens { /// @brief get all dependencies //////////////////////////////////////////////////////////////////////////////// - vector getDependencies () const { + vector getDependencies () const { return _dependencies; } @@ -151,7 +148,7 @@ namespace triagens { /// removed, please note that this does not delete ep! //////////////////////////////////////////////////////////////////////////////// - bool removeDependency (ExecutionPlan* ep) { + bool removeDependency (ExecutionNode* ep) { auto it = _dependencies.begin(); while (it != _dependencies.end()) { if (*it == ep) { @@ -167,7 +164,7 @@ namespace triagens { /// @brief access the pos-th dependency //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* operator[] (size_t pos) const { + ExecutionNode* operator[] (size_t pos) const { if (pos > _dependencies.size()) { return nullptr; } @@ -177,16 +174,16 @@ namespace triagens { } //////////////////////////////////////////////////////////////////////////////// -/// @brief clone execution plan recursively, this makes the class abstract +/// @brief clone execution Node recursively, this makes the class abstract //////////////////////////////////////////////////////////////////////////////// - virtual ExecutionPlan* clone () const = 0; // make class abstract + virtual ExecutionNode* clone () const = 0; // make class abstract //////////////////////////////////////////////////////////////////////////////// /// @brief helper for cloning, use virtual clone methods for dependencies //////////////////////////////////////////////////////////////////////////////// - void cloneDependencies (ExecutionPlan* theClone) const { + void cloneDependencies (ExecutionNode* theClone) const { auto it = _dependencies.begin(); while (it != _dependencies.end()) { theClone->_dependencies.push_back((*it)->clone()); @@ -209,11 +206,11 @@ namespace triagens { protected: triagens::basics::Json toJsonHelperGeneric ( - std::map& indexTab, + std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone); - virtual void toJsonHelper (std::map& indexTab, + virtual void toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone = TRI_UNKNOWN_MEM_ZONE) = 0; @@ -234,12 +231,12 @@ namespace triagens { public: WalkerWorker () {}; virtual ~WalkerWorker () {}; - virtual void before (ExecutionPlan* eb) {}; - virtual void after (ExecutionPlan* eb) {}; - virtual void enterSubquery (ExecutionPlan* super, - ExecutionPlan* sub) {}; - virtual void leaveSubquery (ExecutionPlan* super, - ExecutionPlan* sub) {}; + virtual void before (ExecutionNode* eb) {}; + virtual void after (ExecutionNode* eb) {}; + virtual void enterSubquery (ExecutionNode* super, + ExecutionNode* sub) {}; + virtual void leaveSubquery (ExecutionNode* super, + ExecutionNode* sub) {}; }; void walk (WalkerWorker& worker); @@ -254,19 +251,19 @@ namespace triagens { protected: - std::vector _dependencies; + std::vector _dependencies; }; // ----------------------------------------------------------------------------- -// --SECTION-- class SingletonPlan +// --SECTION-- class SingletonNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief class SingletonPlan, derived from ExecutionPlan +/// @brief class SingletonNode, derived from ExecutionNode //////////////////////////////////////////////////////////////////////////////// - class SingletonPlan : public ExecutionPlan { + class SingletonNode : public ExecutionNode { friend class ExecutionBlock; friend class SingletonBlock; @@ -277,7 +274,7 @@ namespace triagens { public: - SingletonPlan () : ExecutionPlan() { + SingletonNode () : ExecutionNode() { } //////////////////////////////////////////////////////////////////////////////// @@ -293,38 +290,38 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// virtual std::string getTypeString () const { - return std::string("SingletonPlan"); + return std::string("SingletonNode"); } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// - virtual void toJsonHelper (std::map& indexTab, + virtual void toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone = TRI_UNKNOWN_MEM_ZONE); //////////////////////////////////////////////////////////////////////////////// -/// @brief clone execution plan recursively +/// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// - virtual ExecutionPlan* clone () const { - auto c = new SingletonPlan(); + virtual ExecutionNode* clone () const { + auto c = new SingletonNode(); cloneDependencies(c); - return static_cast(c); + return static_cast(c); } }; // ----------------------------------------------------------------------------- -// --SECTION-- class EnumerateCollectionPlan +// --SECTION-- class EnumerateCollectionNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief class EnumerateCollectionPlan, derived from ExecutionPlan +/// @brief class EnumerateCollectionNode, derived from ExecutionNode //////////////////////////////////////////////////////////////////////////////// - class EnumerateCollectionPlan : public ExecutionPlan { + class EnumerateCollectionNode : public ExecutionNode { friend class ExecutionBlock; friend class EnumerateCollectionBlock; @@ -335,10 +332,10 @@ namespace triagens { public: - EnumerateCollectionPlan (TRI_vocbase_t* vocbase, + EnumerateCollectionNode (TRI_vocbase_t* vocbase, std::string collname, Variable const* outVariable) - : ExecutionPlan(), _vocbase(vocbase), _collname(collname), + : ExecutionNode(), _vocbase(vocbase), _collname(collname), _outVariable(outVariable) { TRI_ASSERT(_vocbase != nullptr); @@ -358,25 +355,25 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// virtual std::string getTypeString () const { - return std::string("EnumerateCollectionPlan"); + return std::string("EnumerateCollectionNode"); } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// - virtual void toJsonHelper (std::map& indexTab, + virtual void toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone = TRI_UNKNOWN_MEM_ZONE); //////////////////////////////////////////////////////////////////////////////// -/// @brief clone execution plan recursively +/// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// - virtual ExecutionPlan* clone () const { - auto c = new EnumerateCollectionPlan(_vocbase, _collname, _outVariable); + virtual ExecutionNode* clone () const { + auto c = new EnumerateCollectionNode(_vocbase, _collname, _outVariable); cloneDependencies(c); - return static_cast(c); + return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// @@ -406,14 +403,14 @@ namespace triagens { }; // ----------------------------------------------------------------------------- -// --SECTION-- class EnumerateListPlan +// --SECTION-- class EnumerateListNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief class EnumerateListPlan, derived from ExecutionPlan +/// @brief class EnumerateListNode, derived from ExecutionNode //////////////////////////////////////////////////////////////////////////////// - class EnumerateListPlan : public ExecutionPlan { + class EnumerateListNode : public ExecutionNode { friend class ExecutionBlock; friend class EnumerateListBlock; @@ -424,9 +421,9 @@ namespace triagens { public: - EnumerateListPlan (Variable const* inVariable, + EnumerateListNode (Variable const* inVariable, Variable const* outVariable) - : ExecutionPlan(), _inVariable(inVariable), _outVariable(outVariable) { + : ExecutionNode(), _inVariable(inVariable), _outVariable(outVariable) { TRI_ASSERT(_inVariable != nullptr); TRI_ASSERT(_outVariable != nullptr); @@ -445,25 +442,25 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// virtual std::string getTypeString () const { - return std::string("EnumerateListPlan"); + return std::string("EnumerateListNode"); } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// - virtual void toJsonHelper (std::map& indexTab, + virtual void toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone = TRI_UNKNOWN_MEM_ZONE); //////////////////////////////////////////////////////////////////////////////// -/// @brief clone execution plan recursively +/// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// - virtual ExecutionPlan* clone () const { - auto c = new EnumerateListPlan(_inVariable, _outVariable); + virtual ExecutionNode* clone () const { + auto c = new EnumerateListNode(_inVariable, _outVariable); cloneDependencies(c); - return static_cast(c); + return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// @@ -488,14 +485,14 @@ namespace triagens { // ----------------------------------------------------------------------------- -// --SECTION-- class LimitPlan +// --SECTION-- class LimitNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief class LimitPlan, derived from ExecutionPlan +/// @brief class LimitNode, derived from ExecutionNode //////////////////////////////////////////////////////////////////////////////// - class LimitPlan : public ExecutionPlan { + class LimitNode : public ExecutionNode { friend class ExecutionBlock; friend class LimitBlock; @@ -506,12 +503,12 @@ namespace triagens { public: - LimitPlan (size_t o, size_t l) - : ExecutionPlan(), _offset(o), _limit(l) { + LimitNode (size_t o, size_t l) + : ExecutionNode(), _offset(o), _limit(l) { } - LimitPlan (size_t l) - : ExecutionPlan(), _offset(0), _limit(l) { + LimitNode (size_t l) + : ExecutionNode(), _offset(0), _limit(l) { } //////////////////////////////////////////////////////////////////////////////// @@ -527,25 +524,25 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// virtual std::string getTypeString () const { - return std::string("LimitPlan"); + return std::string("LimitNode"); } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// - virtual void toJsonHelper (std::map& indexTab, + virtual void toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone = TRI_UNKNOWN_MEM_ZONE); //////////////////////////////////////////////////////////////////////////////// -/// @brief clone execution plan recursively +/// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// - virtual ExecutionPlan* clone () const { - auto c = new LimitPlan(_offset, _limit); + virtual ExecutionNode* clone () const { + auto c = new LimitNode(_offset, _limit); cloneDependencies(c); - return static_cast(c); + return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// @@ -560,14 +557,14 @@ namespace triagens { }; // ----------------------------------------------------------------------------- -// --SECTION-- class ProjectionPlan +// --SECTION-- class ProjectionNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief class ProjectionPlan, derived from ExecutionPlan +/// @brief class ProjectionNode, derived from ExecutionNode //////////////////////////////////////////////////////////////////////////////// - class ProjectionPlan : public ExecutionPlan { + class ProjectionNode : public ExecutionNode { friend class ExecutionBlock; friend class ProjectionBlock; @@ -578,10 +575,10 @@ namespace triagens { public: - ProjectionPlan (Variable const* inVariable, + ProjectionNode (Variable const* inVariable, Variable const* outVariable, std::vector keepAttributes) - : ExecutionPlan(), _inVariable(inVariable), _outVariable(outVariable), + : ExecutionNode(), _inVariable(inVariable), _outVariable(outVariable), _keepAttributes(keepAttributes) { TRI_ASSERT(inVariable != nullptr); @@ -601,25 +598,25 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// virtual std::string getTypeString () const { - return std::string("ProjectionPlan"); + return std::string("ProjectionNode"); } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// - virtual void toJsonHelper (std::map& indexTab, + virtual void toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone = TRI_UNKNOWN_MEM_ZONE); //////////////////////////////////////////////////////////////////////////////// -/// @brief clone execution plan recursively +/// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// - virtual ExecutionPlan* clone () const { - auto c = new ProjectionPlan(_inVariable, _outVariable, _keepAttributes); + virtual ExecutionNode* clone () const { + auto c = new ProjectionNode(_inVariable, _outVariable, _keepAttributes); cloneDependencies(c); - return static_cast(c); + return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// @@ -649,14 +646,14 @@ namespace triagens { }; // ----------------------------------------------------------------------------- -// --SECTION-- class CalculationPlan +// --SECTION-- class CalculationNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief class CalculationPlan, derived from ExecutionPlan +/// @brief class CalculationNode, derived from ExecutionNode //////////////////////////////////////////////////////////////////////////////// - class CalculationPlan : public ExecutionPlan { + class CalculationNode : public ExecutionNode { friend class ExecutionBlock; friend class CalculationBlock; @@ -667,8 +664,8 @@ namespace triagens { /// @brief constructor //////////////////////////////////////////////////////////////////////////////// - CalculationPlan (Expression* expr, Variable const* outVariable) - : ExecutionPlan(), _expression(expr), _outVariable(outVariable) { + CalculationNode (Expression* expr, Variable const* outVariable) + : ExecutionNode(), _expression(expr), _outVariable(outVariable) { TRI_ASSERT(_expression != nullptr); TRI_ASSERT(_outVariable != nullptr); @@ -678,7 +675,7 @@ namespace triagens { /// @brief destructor //////////////////////////////////////////////////////////////////////////////// - ~CalculationPlan () { + ~CalculationNode () { if (_expression != nullptr) { delete _expression; } @@ -697,25 +694,25 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// virtual std::string getTypeString () const { - return std::string("CalculationPlan"); + return std::string("CalculationNode"); } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// - virtual void toJsonHelper (std::map& indexTab, + virtual void toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone = TRI_UNKNOWN_MEM_ZONE); //////////////////////////////////////////////////////////////////////////////// -/// @brief clone execution plan recursively +/// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// - virtual ExecutionPlan* clone () const { - auto c = new CalculationPlan(_expression->clone(), _outVariable); + virtual ExecutionNode* clone () const { + auto c = new CalculationNode(_expression->clone(), _outVariable); cloneDependencies(c); - return static_cast(c); + return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// @@ -747,14 +744,14 @@ namespace triagens { }; // ----------------------------------------------------------------------------- -// --SECTION-- class SubqueryPlan +// --SECTION-- class SubqueryNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief class SubqueryPlan, derived from ExecutionPlan +/// @brief class SubqueryNode, derived from ExecutionNode //////////////////////////////////////////////////////////////////////////////// - class SubqueryPlan : public ExecutionPlan { + class SubqueryNode : public ExecutionNode { friend class ExecutionBlock; friend class SubqueryBlock; @@ -765,8 +762,8 @@ namespace triagens { public: - SubqueryPlan (ExecutionPlan* subquery, Variable const* outVariable) - : ExecutionPlan(), _subquery(subquery), _outVariable(outVariable) { + SubqueryNode (ExecutionNode* subquery, Variable const* outVariable) + : ExecutionNode(), _subquery(subquery), _outVariable(outVariable) { TRI_ASSERT(_subquery != nullptr); TRI_ASSERT(_outVariable != nullptr); @@ -785,32 +782,32 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// virtual std::string getTypeString () const { - return std::string("SubqueryPlan"); + return std::string("SubqueryNode"); } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// - virtual void toJsonHelper (std::map& indexTab, + virtual void toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone = TRI_UNKNOWN_MEM_ZONE); //////////////////////////////////////////////////////////////////////////////// -/// @brief clone execution plan recursively +/// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// - virtual ExecutionPlan* clone () const { - auto c = new SubqueryPlan(_subquery->clone(), _outVariable); + virtual ExecutionNode* clone () const { + auto c = new SubqueryNode(_subquery->clone(), _outVariable); cloneDependencies(c); - return static_cast(c); + return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// /// @brief getter for subquery //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* getSubquery () { + ExecutionNode* getSubquery () { return _subquery; } @@ -824,7 +821,7 @@ namespace triagens { /// @brief we need to have an expression and where to write the result //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* _subquery; + ExecutionNode* _subquery; //////////////////////////////////////////////////////////////////////////////// /// @brief variable to write to @@ -835,14 +832,14 @@ namespace triagens { }; // ----------------------------------------------------------------------------- -// --SECTION-- class FilterPlan +// --SECTION-- class FilterNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief class FilterPlan, derived from ExecutionPlan +/// @brief class FilterNode, derived from ExecutionNode //////////////////////////////////////////////////////////////////////////////// - class FilterPlan : public ExecutionPlan { + class FilterNode : public ExecutionNode { friend class ExecutionBlock; friend class FilterBlock; @@ -853,8 +850,8 @@ namespace triagens { public: - FilterPlan (Variable const* inVariable) - : ExecutionPlan(), _inVariable(inVariable) { + FilterNode (Variable const* inVariable) + : ExecutionNode(), _inVariable(inVariable) { TRI_ASSERT(_inVariable != nullptr); } @@ -872,25 +869,25 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// virtual std::string getTypeString () const { - return std::string("FilterPlan"); + return std::string("FilterNode"); } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// - virtual void toJsonHelper (std::map& indexTab, + virtual void toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone = TRI_UNKNOWN_MEM_ZONE); //////////////////////////////////////////////////////////////////////////////// -/// @brief clone execution plan recursively +/// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// - virtual ExecutionPlan* clone () const { - auto c = new FilterPlan(_inVariable); + virtual ExecutionNode* clone () const { + auto c = new FilterNode(_inVariable); cloneDependencies(c); - return static_cast(c); + return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// @@ -908,14 +905,14 @@ namespace triagens { }; // ----------------------------------------------------------------------------- -// --SECTION-- class SortPlan +// --SECTION-- class SortNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief class SortPlan, derived from ExecutionPlan +/// @brief class SortNode, derived from ExecutionNode //////////////////////////////////////////////////////////////////////////////// - class SortPlan : public ExecutionPlan { + class SortNode : public ExecutionNode { friend class ExecutionBlock; friend class SortBlock; @@ -926,8 +923,8 @@ namespace triagens { public: - SortPlan (std::vector> elements) - : ExecutionPlan(), _elements(elements) { + SortNode (std::vector> elements) + : ExecutionNode(), _elements(elements) { } //////////////////////////////////////////////////////////////////////////////// @@ -943,25 +940,25 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// virtual std::string getTypeString () const { - return std::string("SortPlan"); + return std::string("SortNode"); } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// - virtual void toJsonHelper (std::map& indexTab, + virtual void toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone = TRI_UNKNOWN_MEM_ZONE); //////////////////////////////////////////////////////////////////////////////// -/// @brief clone execution plan recursively +/// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// - virtual ExecutionPlan* clone () const { - auto c = new SortPlan(_elements); + virtual ExecutionNode* clone () const { + auto c = new SortNode(_elements); cloneDependencies(c); - return static_cast(c); + return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// @@ -981,14 +978,14 @@ namespace triagens { // ----------------------------------------------------------------------------- -// --SECTION-- class AggregateOnUnsortedPlan +// --SECTION-- class AggregateOnUnsortedNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief class AggregateOnUnsortedPlan, derived from ExecutionPlan +/// @brief class AggregateOnUnsortedNode, derived from ExecutionNode //////////////////////////////////////////////////////////////////////////////// - class AggregateOnUnsortedPlan : public ExecutionPlan { + class AggregateOnUnsortedNode : public ExecutionNode { friend class ExecutionBlock; friend class AggregateOnUnsortedBlock; @@ -999,9 +996,9 @@ namespace triagens { public: - AggregateOnUnsortedPlan (std::vector> aggregateVariables, + AggregateOnUnsortedNode (std::vector> aggregateVariables, Variable const* outVariable) - : ExecutionPlan(), _aggregateVariables(aggregateVariables), _outVariable(outVariable) { + : ExecutionNode(), _aggregateVariables(aggregateVariables), _outVariable(outVariable) { } //////////////////////////////////////////////////////////////////////////////// @@ -1017,25 +1014,25 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// virtual std::string getTypeString () const { - return std::string("AggregateOnUnsortedPlan"); + return std::string("AggregateOnUnsortedNode"); } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// - virtual void toJsonHelper (std::map& indexTab, + virtual void toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone = TRI_UNKNOWN_MEM_ZONE); //////////////////////////////////////////////////////////////////////////////// -/// @brief clone execution plan recursively +/// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// - virtual ExecutionPlan* clone () const { - auto c = new AggregateOnUnsortedPlan(_aggregateVariables, _outVariable); + virtual ExecutionNode* clone () const { + auto c = new AggregateOnUnsortedNode(_aggregateVariables, _outVariable); cloneDependencies(c); - return static_cast(c); + return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// @@ -1060,14 +1057,14 @@ namespace triagens { // ----------------------------------------------------------------------------- -// --SECTION-- class RootPlan +// --SECTION-- class RootNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// -/// @brief class RootPlan, derived from ExecutionPlan +/// @brief class RootNode, derived from ExecutionNode //////////////////////////////////////////////////////////////////////////////// - class RootPlan : public ExecutionPlan { + class RootNode : public ExecutionNode { friend class ExecutionBlock; friend class RootBlock; @@ -1078,8 +1075,8 @@ namespace triagens { public: - RootPlan (Variable const* inVariable) - : ExecutionPlan(), _inVariable(inVariable) { + RootNode (Variable const* inVariable) + : ExecutionNode(), _inVariable(inVariable) { TRI_ASSERT(_inVariable != nullptr); } @@ -1097,25 +1094,25 @@ namespace triagens { //////////////////////////////////////////////////////////////////////////////// virtual std::string getTypeString () const { - return std::string("RootPlan"); + return std::string("RootNode"); } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// - virtual void toJsonHelper (std::map& indexTab, + virtual void toJsonHelper (std::map& indexTab, triagens::basics::Json& nodes, TRI_memory_zone_t* zone = TRI_UNKNOWN_MEM_ZONE); //////////////////////////////////////////////////////////////////////////////// -/// @brief clone execution plan recursively +/// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// - virtual ExecutionPlan* clone () const { - auto c = new RootPlan(_inVariable); + virtual ExecutionNode* clone () const { + auto c = new RootNode(_inVariable); cloneDependencies(c); - return static_cast(c); + return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// diff --git a/arangod/Aql/PlanGenerator.cpp b/arangod/Aql/PlanGenerator.cpp index c63c032768..f1d1603253 100644 --- a/arangod/Aql/PlanGenerator.cpp +++ b/arangod/Aql/PlanGenerator.cpp @@ -64,14 +64,14 @@ PlanGenerator::~PlanGenerator () { /// @brief create an initial execution plan from an abstract syntax tree //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::fromAst (Ast const* ast) { +ExecutionNode* PlanGenerator::fromAst (Ast const* ast) { TRI_ASSERT(ast != nullptr); auto root = ast->root(); TRI_ASSERT(root != nullptr); TRI_ASSERT(root->type == NODE_TYPE_ROOT); - ExecutionPlan* plan = fromNode(ast, root); + ExecutionNode* plan = fromNode(ast, root); return plan; } @@ -84,7 +84,7 @@ ExecutionPlan* PlanGenerator::fromAst (Ast const* ast) { /// @brief creates a calculation node for an arbitrary expression //////////////////////////////////////////////////////////////////////////////// -CalculationPlan* PlanGenerator::createTemporaryCalculation (Ast const* ast, +CalculationNode* PlanGenerator::createTemporaryCalculation (Ast const* ast, AstNode const* expression) { // generate a temporary variable auto out = ast->variables()->createTemporaryVariable(); @@ -94,7 +94,7 @@ CalculationPlan* PlanGenerator::createTemporaryCalculation (Ast const* ast, auto expr = new Expression(ast->query()->executor(), const_cast(expression)); try { - return new CalculationPlan(expr, out); + return new CalculationNode(expr, out); } catch (...) { // prevent memleak @@ -108,8 +108,8 @@ CalculationPlan* PlanGenerator::createTemporaryCalculation (Ast const* ast, /// @brief adds "previous" as dependency to "plan", returns "plan" //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::addDependency (ExecutionPlan* previous, - ExecutionPlan* plan) { +ExecutionNode* PlanGenerator::addDependency (ExecutionNode* previous, + ExecutionNode* plan) { TRI_ASSERT(previous != nullptr); TRI_ASSERT(plan != nullptr); @@ -128,8 +128,8 @@ ExecutionPlan* PlanGenerator::addDependency (ExecutionPlan* previous, /// @brief create an execution plan element from an AST FOR node //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::fromNodeFor (Ast const* ast, - ExecutionPlan* previous, +ExecutionNode* PlanGenerator::fromNodeFor (Ast const* ast, + ExecutionNode* previous, AstNode const* node) { TRI_ASSERT(node != nullptr && node->type == NODE_TYPE_FOR); TRI_ASSERT(node->numMembers() == 2); @@ -142,26 +142,26 @@ ExecutionPlan* PlanGenerator::fromNodeFor (Ast const* ast, auto v = static_cast(variable->getData()); TRI_ASSERT(v != nullptr); - ExecutionPlan* plan = nullptr; + ExecutionNode* plan = nullptr; // peek at second operand if (expression->type == NODE_TYPE_COLLECTION) { // second operand is a collection char const* collectionName = expression->getStringValue(); - plan = new EnumerateCollectionPlan(ast->query()->vocbase(), std::string(collectionName), v); + plan = new EnumerateCollectionNode(ast->query()->vocbase(), std::string(collectionName), v); } else if (expression->type == NODE_TYPE_REFERENCE) { // second operand is already a variable auto inVariable = static_cast(variable->getData()); TRI_ASSERT(inVariable != nullptr); - plan = new EnumerateListPlan(inVariable, v); + plan = new EnumerateListNode(inVariable, v); } else { // second operand is some misc. expression auto calc = createTemporaryCalculation(ast, expression); try { - plan = new EnumerateListPlan(calc->outVariable(), v); + plan = new EnumerateListNode(calc->outVariable(), v); plan->addDependency(calc); } catch (...) { @@ -179,28 +179,28 @@ ExecutionPlan* PlanGenerator::fromNodeFor (Ast const* ast, /// @brief create an execution plan element from an AST FILTER node //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::fromNodeFilter (Ast const* ast, - ExecutionPlan* previous, +ExecutionNode* PlanGenerator::fromNodeFilter (Ast const* ast, + ExecutionNode* previous, AstNode const* node) { TRI_ASSERT(node != nullptr && node->type == NODE_TYPE_FILTER); TRI_ASSERT(node->numMembers() == 1); auto expression = node->getMember(0); - ExecutionPlan* plan = nullptr; + ExecutionNode* plan = nullptr; if (expression->type == NODE_TYPE_REFERENCE) { // operand is already a variable auto v = static_cast(expression->getData()); TRI_ASSERT(v != nullptr); - plan = new FilterPlan(v); + plan = new FilterNode(v); } else { // operand is some misc expression auto calc = createTemporaryCalculation(ast, expression); try { - plan = new FilterPlan(calc->outVariable()); + plan = new FilterNode(calc->outVariable()); plan->addDependency(calc); } catch (...) { @@ -216,8 +216,8 @@ ExecutionPlan* PlanGenerator::fromNodeFilter (Ast const* ast, /// @brief create an execution plan element from an AST LET node //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::fromNodeLet (Ast const* ast, - ExecutionPlan* previous, +ExecutionNode* PlanGenerator::fromNodeLet (Ast const* ast, + ExecutionNode* previous, AstNode const* node) { TRI_ASSERT(node != nullptr && node->type == NODE_TYPE_LET); TRI_ASSERT(node->numMembers() == 2); @@ -227,7 +227,7 @@ ExecutionPlan* PlanGenerator::fromNodeLet (Ast const* ast, auto v = static_cast(variable->getData()); - ExecutionPlan* plan = nullptr; + ExecutionNode* plan = nullptr; if (expression->type == NODE_TYPE_SUBQUERY) { // TODO: node might be a subquery. this is currently NOT handled @@ -238,7 +238,7 @@ ExecutionPlan* PlanGenerator::fromNodeLet (Ast const* ast, auto expr = new Expression(ast->query()->executor(), const_cast(expression)); try { - plan = new CalculationPlan(expr, v); + plan = new CalculationNode(expr, v); } catch (...) { // prevent memleak @@ -254,8 +254,8 @@ ExecutionPlan* PlanGenerator::fromNodeLet (Ast const* ast, /// @brief create an execution plan element from an AST SORT node //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::fromNodeSort (Ast const* ast, - ExecutionPlan* previous, +ExecutionNode* PlanGenerator::fromNodeSort (Ast const* ast, + ExecutionNode* previous, AstNode const* node) { TRI_ASSERT(node != nullptr && node->type == NODE_TYPE_SORT); TRI_ASSERT(node->numMembers() == 1); @@ -264,7 +264,7 @@ ExecutionPlan* PlanGenerator::fromNodeSort (Ast const* ast, TRI_ASSERT(list->type == NODE_TYPE_LIST); std::vector> elements; - std::vector temp; + std::vector temp; try { size_t const n = list->numMembers(); @@ -306,7 +306,7 @@ ExecutionPlan* PlanGenerator::fromNodeSort (Ast const* ast, previous = (*it); } - auto plan = new SortPlan(elements); + auto plan = new SortNode(elements); return addDependency(previous, plan); } @@ -315,8 +315,8 @@ ExecutionPlan* PlanGenerator::fromNodeSort (Ast const* ast, /// @brief create an execution plan element from an AST COLLECT node //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::fromNodeCollect (Ast const* ast, - ExecutionPlan* previous, +ExecutionNode* PlanGenerator::fromNodeCollect (Ast const* ast, + ExecutionNode* previous, AstNode const* node) { TRI_ASSERT(node != nullptr && node->type == NODE_TYPE_COLLECT); size_t const n = node->numMembers(); @@ -333,8 +333,8 @@ ExecutionPlan* PlanGenerator::fromNodeCollect (Ast const* ast, /// @brief create an execution plan element from an AST LIMIT node //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::fromNodeLimit (Ast const* ast, - ExecutionPlan* previous, +ExecutionNode* PlanGenerator::fromNodeLimit (Ast const* ast, + ExecutionNode* previous, AstNode const* node) { TRI_ASSERT(node != nullptr && node->type == NODE_TYPE_LIMIT); TRI_ASSERT(node->numMembers() == 2); @@ -345,7 +345,7 @@ ExecutionPlan* PlanGenerator::fromNodeLimit (Ast const* ast, TRI_ASSERT(offset->type == NODE_TYPE_VALUE); TRI_ASSERT(count->type == NODE_TYPE_VALUE); - auto plan = new LimitPlan(static_cast(offset->getIntValue()), static_cast(count->getIntValue())); + auto plan = new LimitNode(static_cast(offset->getIntValue()), static_cast(count->getIntValue())); return addDependency(previous, plan); } @@ -354,28 +354,28 @@ ExecutionPlan* PlanGenerator::fromNodeLimit (Ast const* ast, /// @brief create an execution plan element from an AST RETURN node //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::fromNodeReturn (Ast const* ast, - ExecutionPlan* previous, +ExecutionNode* PlanGenerator::fromNodeReturn (Ast const* ast, + ExecutionNode* previous, AstNode const* node) { TRI_ASSERT(node != nullptr && node->type == NODE_TYPE_RETURN); TRI_ASSERT(node->numMembers() == 1); auto expression = node->getMember(0); - ExecutionPlan* plan = nullptr; + ExecutionNode* plan = nullptr; if (expression->type == NODE_TYPE_REFERENCE) { // operand is already a variable auto v = static_cast(expression->getData()); TRI_ASSERT(v != nullptr); - plan = new RootPlan(v); + plan = new RootNode(v); } else { // operand is some misc expression auto calc = createTemporaryCalculation(ast, expression); try { - plan = new RootPlan(calc->outVariable()); + plan = new RootNode(calc->outVariable()); plan->addDependency(calc); } catch (...) { @@ -391,8 +391,8 @@ ExecutionPlan* PlanGenerator::fromNodeReturn (Ast const* ast, /// @brief create an execution plan element from an AST REMOVE node //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::fromNodeRemove (Ast const* ast, - ExecutionPlan* previous, +ExecutionNode* PlanGenerator::fromNodeRemove (Ast const* ast, + ExecutionNode* previous, AstNode const* node) { TRI_ASSERT(node != nullptr && node->type == NODE_TYPE_REMOVE); @@ -406,8 +406,8 @@ ExecutionPlan* PlanGenerator::fromNodeRemove (Ast const* ast, /// @brief create an execution plan element from an AST INSERT node //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::fromNodeInsert (Ast const* ast, - ExecutionPlan* previous, +ExecutionNode* PlanGenerator::fromNodeInsert (Ast const* ast, + ExecutionNode* previous, AstNode const* node) { TRI_ASSERT(node != nullptr && node->type == NODE_TYPE_INSERT); @@ -421,8 +421,8 @@ ExecutionPlan* PlanGenerator::fromNodeInsert (Ast const* ast, /// @brief create an execution plan element from an AST UPDATE node //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::fromNodeUpdate (Ast const* ast, - ExecutionPlan* previous, +ExecutionNode* PlanGenerator::fromNodeUpdate (Ast const* ast, + ExecutionNode* previous, AstNode const* node) { TRI_ASSERT(node != nullptr && node->type == NODE_TYPE_UPDATE); @@ -436,8 +436,8 @@ ExecutionPlan* PlanGenerator::fromNodeUpdate (Ast const* ast, /// @brief create an execution plan element from an AST REPLACE node //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::fromNodeReplace (Ast const* ast, - ExecutionPlan* previous, +ExecutionNode* PlanGenerator::fromNodeReplace (Ast const* ast, + ExecutionNode* previous, AstNode const* node) { TRI_ASSERT(node != nullptr && node->type == NODE_TYPE_REPLACE); @@ -451,11 +451,11 @@ ExecutionPlan* PlanGenerator::fromNodeReplace (Ast const* ast, /// @brief create an execution plan from an abstract syntax tree node //////////////////////////////////////////////////////////////////////////////// -ExecutionPlan* PlanGenerator::fromNode (Ast const* ast, +ExecutionNode* PlanGenerator::fromNode (Ast const* ast, AstNode const* node) { TRI_ASSERT(node != nullptr); - ExecutionPlan* plan = new SingletonPlan(); + ExecutionNode* plan = new SingletonNode(); try { size_t const n = node->numMembers(); diff --git a/arangod/Aql/PlanGenerator.h b/arangod/Aql/PlanGenerator.h index 453b595811..cd1b3273b2 100644 --- a/arangod/Aql/PlanGenerator.h +++ b/arangod/Aql/PlanGenerator.h @@ -37,8 +37,8 @@ namespace triagens { class Ast; struct AstNode; - class CalculationPlan; - class ExecutionPlan; + class CalculationNode; + class ExecutionNode; // ----------------------------------------------------------------------------- // --SECTION-- class PlanGenerator @@ -74,7 +74,7 @@ namespace triagens { /// @brief create an initial execution plan from an abstract syntax tree //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* fromAst (Ast const*); + ExecutionNode* fromAst (Ast const*); // ----------------------------------------------------------------------------- // --SECTION-- private methods @@ -86,109 +86,109 @@ namespace triagens { /// @brief creates a calculation node for an arbitrary expression //////////////////////////////////////////////////////////////////////////////// - CalculationPlan* createTemporaryCalculation (Ast const*, + CalculationNode* createTemporaryCalculation (Ast const*, AstNode const*); //////////////////////////////////////////////////////////////////////////////// /// @brief adds "previous" as dependency to "plan", returns "plan" //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* addDependency (ExecutionPlan*, - ExecutionPlan*); + ExecutionNode* addDependency (ExecutionNode*, + ExecutionNode*); //////////////////////////////////////////////////////////////////////////////// /// @brief create an execution plan element from an AST FOR node //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* fromNodeFor (Ast const*, - ExecutionPlan*, + ExecutionNode* fromNodeFor (Ast const*, + ExecutionNode*, AstNode const*); //////////////////////////////////////////////////////////////////////////////// /// @brief create an execution plan element from an AST FILTER node //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* fromNodeFilter (Ast const*, - ExecutionPlan*, + ExecutionNode* fromNodeFilter (Ast const*, + ExecutionNode*, AstNode const*); //////////////////////////////////////////////////////////////////////////////// /// @brief create an execution plan element from an AST LET node //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* fromNodeLet (Ast const*, - ExecutionPlan*, + ExecutionNode* fromNodeLet (Ast const*, + ExecutionNode*, AstNode const*); //////////////////////////////////////////////////////////////////////////////// /// @brief create an execution plan element from an AST SORT node //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* fromNodeSort (Ast const*, - ExecutionPlan*, + ExecutionNode* fromNodeSort (Ast const*, + ExecutionNode*, AstNode const*); //////////////////////////////////////////////////////////////////////////////// /// @brief create an execution plan element from an AST COLLECT node //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* fromNodeCollect (Ast const*, - ExecutionPlan*, + ExecutionNode* fromNodeCollect (Ast const*, + ExecutionNode*, AstNode const*); //////////////////////////////////////////////////////////////////////////////// /// @brief create an execution plan element from an AST LIMIT node //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* fromNodeLimit (Ast const*, - ExecutionPlan*, + ExecutionNode* fromNodeLimit (Ast const*, + ExecutionNode*, AstNode const*); //////////////////////////////////////////////////////////////////////////////// /// @brief create an execution plan element from an AST RETURN node //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* fromNodeReturn (Ast const*, - ExecutionPlan*, + ExecutionNode* fromNodeReturn (Ast const*, + ExecutionNode*, AstNode const*); //////////////////////////////////////////////////////////////////////////////// /// @brief create an execution plan element from an AST REMOVE node //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* fromNodeRemove (Ast const*, - ExecutionPlan*, + ExecutionNode* fromNodeRemove (Ast const*, + ExecutionNode*, AstNode const*); //////////////////////////////////////////////////////////////////////////////// /// @brief create an execution plan element from an AST INSERT node //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* fromNodeInsert (Ast const*, - ExecutionPlan*, + ExecutionNode* fromNodeInsert (Ast const*, + ExecutionNode*, AstNode const*); //////////////////////////////////////////////////////////////////////////////// /// @brief create an execution plan element from an AST UPDATE node //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* fromNodeUpdate (Ast const*, - ExecutionPlan*, + ExecutionNode* fromNodeUpdate (Ast const*, + ExecutionNode*, AstNode const*); //////////////////////////////////////////////////////////////////////////////// /// @brief create an execution plan element from an AST REPLACE node //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* fromNodeReplace (Ast const*, - ExecutionPlan*, + ExecutionNode* fromNodeReplace (Ast const*, + ExecutionNode*, AstNode const*); //////////////////////////////////////////////////////////////////////////////// /// @brief create an execution plan from an abstract syntax tree node //////////////////////////////////////////////////////////////////////////////// - ExecutionPlan* fromNode (Ast const*, + ExecutionNode* fromNode (Ast const*, AstNode const*); // -----------------------------------------------------------------------------