//////////////////////////////////////////////////////////////////////////////// /// DISCLAIMER /// /// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany /// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany /// /// Licensed under the Apache License, Version 2.0 (the "License"); /// you may not use this file except in compliance with the License. /// You may obtain a copy of the License at /// /// http://www.apache.org/licenses/LICENSE-2.0 /// /// Unless required by applicable law or agreed to in writing, software /// distributed under the License is distributed on an "AS IS" BASIS, /// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. /// See the License for the specific language governing permissions and /// limitations under the License. /// /// Copyright holder is ArangoDB GmbH, Cologne, Germany /// /// @author Max Neunhoeffer //////////////////////////////////////////////////////////////////////////////// #ifndef ARANGOD_AQL_EXECUTION_NODE_H #define ARANGOD_AQL_EXECUTION_NODE_H 1 #include "Basics/Common.h" #include "Aql/types.h" #include "Aql/Expression.h" #include "Aql/Variable.h" #include "Aql/WalkerWorker.h" #include "Basics/JsonHelper.h" #include "Basics/json-utilities.h" #include "VocBase/voc-types.h" #include "VocBase/vocbase.h" namespace arangodb { namespace velocypack { class Builder; } namespace aql { class Ast; struct Collection; class ExecutionBlock; class TraversalBlock; class ExecutionPlan; struct Index; class RedundantCalculationsReplacer; //////////////////////////////////////////////////////////////////////////////// /// @brief pairs, consisting of variable and sort direction /// (true = ascending | false = descending) //////////////////////////////////////////////////////////////////////////////// typedef std::vector> SortElementVector; //////////////////////////////////////////////////////////////////////////////// /// @brief class ExecutionNode, abstract base class of all execution Nodes //////////////////////////////////////////////////////////////////////////////// class ExecutionNode { ////////////////////////////////////////////////////////////////////////////// /// @brief node type ////////////////////////////////////////////////////////////////////////////// friend class ExecutionBlock; friend class TraversalBlock; public: enum NodeType : int { ILLEGAL = 0, SINGLETON = 1, ENUMERATE_COLLECTION = 2, // INDEX_RANGE = 3, // not used anymore ENUMERATE_LIST = 4, FILTER = 5, LIMIT = 6, CALCULATION = 7, SUBQUERY = 8, SORT = 9, COLLECT = 10, SCATTER = 11, GATHER = 12, REMOTE = 13, INSERT = 14, REMOVE = 15, REPLACE = 16, UPDATE = 17, RETURN = 18, NORESULTS = 19, DISTRIBUTE = 20, UPSERT = 21, TRAVERSAL = 22, INDEX = 23 }; ExecutionNode() = delete; ExecutionNode(ExecutionNode const&) = delete; ExecutionNode& operator=(ExecutionNode const&) = delete; ////////////////////////////////////////////////////////////////////////////// /// @brief constructor using an id ////////////////////////////////////////////////////////////////////////////// ExecutionNode(ExecutionPlan* plan, size_t id) : _id(id), _estimatedCost(0.0), _estimatedNrItems(0), _estimatedCostSet(false), _depth(0), _varUsageValid(false), _plan(plan) {} ////////////////////////////////////////////////////////////////////////////// /// @brief constructor using a JSON struct ////////////////////////////////////////////////////////////////////////////// ExecutionNode(ExecutionPlan* plan, arangodb::basics::Json const& json); ////////////////////////////////////////////////////////////////////////////// /// @brief destructor, free dependencies; ////////////////////////////////////////////////////////////////////////////// virtual ~ExecutionNode() {} public: ////////////////////////////////////////////////////////////////////////////// /// @brief factory from json. ////////////////////////////////////////////////////////////////////////////// static ExecutionNode* fromJsonFactory(ExecutionPlan* plan, arangodb::basics::Json const& json); ////////////////////////////////////////////////////////////////////////////// /// @brief return the node's id ////////////////////////////////////////////////////////////////////////////// inline size_t id() const { return _id; } ////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node ////////////////////////////////////////////////////////////////////////////// virtual NodeType getType() const = 0; ////////////////////////////////////////////////////////////////////////////// /// @brief return the type name of the node ////////////////////////////////////////////////////////////////////////////// std::string const& getTypeString() const; ////////////////////////////////////////////////////////////////////////////// /// @brief checks whether we know a type of this kind; throws exception if /// not. ////////////////////////////////////////////////////////////////////////////// static void validateType(int type); ////////////////////////////////////////////////////////////////////////////// /// @brief add a dependency ////////////////////////////////////////////////////////////////////////////// void addDependency(ExecutionNode* ep) { _dependencies.emplace_back(ep); ep->_parents.emplace_back(this); } ////////////////////////////////////////////////////////////////////////////// /// @brief add a parent ////////////////////////////////////////////////////////////////////////////// void addParent(ExecutionNode* ep) { ep->_dependencies.emplace_back(this); _parents.emplace_back(ep); } ////////////////////////////////////////////////////////////////////////////// /// @brief get all dependencies ////////////////////////////////////////////////////////////////////////////// std::vector getDependencies() const { return _dependencies; } ////////////////////////////////////////////////////////////////////////////// /// @brief returns the first dependency, or a nullptr if none present ////////////////////////////////////////////////////////////////////////////// ExecutionNode* getFirstDependency() const { if (_dependencies.empty()) { return nullptr; } return _dependencies[0]; } ////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the node has a dependency ////////////////////////////////////////////////////////////////////////////// bool hasDependency() const { return (_dependencies.size() == 1); } ////////////////////////////////////////////////////////////////////////////// /// @brief add the node dependencies to a vector ////////////////////////////////////////////////////////////////////////////// void addDependencies(std::vector& result) const { for (auto const& it : _dependencies) { result.emplace_back(it); } } ////////////////////////////////////////////////////////////////////////////// /// @brief get all parents ////////////////////////////////////////////////////////////////////////////// std::vector getParents() const { return _parents; } ////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the node has a parent ////////////////////////////////////////////////////////////////////////////// bool hasParent() const { return (_parents.size() == 1); } ////////////////////////////////////////////////////////////////////////////// /// @brief returns the first parent, or a nullptr if none present ////////////////////////////////////////////////////////////////////////////// ExecutionNode* getFirstParent() const { if (_parents.empty()) { return nullptr; } return _parents[0]; } ////////////////////////////////////////////////////////////////////////////// /// @brief add the node parents to a vector ////////////////////////////////////////////////////////////////////////////// void addParents(std::vector& result) const { for (auto const& it : _parents) { result.emplace_back(it); } } ////////////////////////////////////////////////////////////////////////////// /// @brief get the node and its dependencies as a vector ////////////////////////////////////////////////////////////////////////////// std::vector getDependencyChain(bool includeSelf) { std::vector result; auto current = this; while (current != nullptr) { if (includeSelf || current != this) { result.emplace_back(current); } if (! current->hasDependency()) { break; } current = current->getFirstDependency(); } return result; } ////////////////////////////////////////////////////////////////////////////// /// @brief inspect one index; only skiplist indices which match attrs in /// sequence. /// returns a a qualification how good they match; /// match->index==nullptr means no match at all. ////////////////////////////////////////////////////////////////////////////// enum MatchType { FORWARD_MATCH, REVERSE_MATCH, NOT_COVERED_IDX, NOT_COVERED_ATTR, NO_MATCH }; struct IndexMatch { IndexMatch() : index(nullptr), doesMatch(false), reverse(false) {} Index const* index; // The index concerned; if null, this is a nonmatch. std::vector matches; // qualification of the attrs match quality bool doesMatch; // do all criteria match? bool reverse; // reverse index scan required }; typedef std::vector> IndexMatchVec; ////////////////////////////////////////////////////////////////////////////// /// @brief make a new node the (only) parent of the node ////////////////////////////////////////////////////////////////////////////// void setParent(ExecutionNode* p) { _parents.clear(); _parents.emplace_back(p); } ////////////////////////////////////////////////////////////////////////////// /// @brief replace a dependency, returns true if the pointer was found and /// replaced, please note that this does not delete oldNode! ////////////////////////////////////////////////////////////////////////////// bool replaceDependency(ExecutionNode* oldNode, ExecutionNode* newNode) { auto it = _dependencies.begin(); while (it != _dependencies.end()) { if (*it == oldNode) { *it = newNode; try { newNode->_parents.emplace_back(this); } catch (...) { *it = oldNode; // roll back return false; } try { for (auto it2 = oldNode->_parents.begin(); it2 != oldNode->_parents.end(); ++it2) { if (*it2 == this) { oldNode->_parents.erase(it2); break; } } } catch (...) { // If this happens, we ignore that the _parents of oldNode // are not set correctly } return true; } ++it; } return false; } ////////////////////////////////////////////////////////////////////////////// /// @brief remove a dependency, returns true if the pointer was found and /// removed, please note that this does not delete ep! ////////////////////////////////////////////////////////////////////////////// bool removeDependency(ExecutionNode* ep) { bool ok = false; for (auto it = _dependencies.begin(); it != _dependencies.end(); ++it) { if (*it == ep) { try { it = _dependencies.erase(it); } catch (...) { return false; } ok = true; break; } } if (!ok) { return false; } // Now remove us as a parent of the old dependency as well: for (auto it = ep->_parents.begin(); it != ep->_parents.end(); ++it) { if (*it == this) { try { ep->_parents.erase(it); } catch (...) { } return true; } } return false; } ////////////////////////////////////////////////////////////////////////////// /// @brief remove all dependencies for the given node ////////////////////////////////////////////////////////////////////////////// void removeDependencies() { for (auto& x : _dependencies) { for (auto it = x->_parents.begin(); it != x->_parents.end(); ++it) { if (*it == this) { try { x->_parents.erase(it); } catch (...) { } break; } } } _dependencies.clear(); } ////////////////////////////////////////////////////////////////////////////// /// @brief clone execution Node recursively, this makes the class abstract ////////////////////////////////////////////////////////////////////////////// virtual ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies, bool withProperties) const = 0; ////////////////////////////////////////////////////////////////////////////// /// @brief execution Node clone utility to be called by derives ////////////////////////////////////////////////////////////////////////////// void cloneHelper(ExecutionNode* Other, ExecutionPlan* plan, bool withDependencies, bool withProperties) const; ////////////////////////////////////////////////////////////////////////////// /// @brief helper for cloning, use virtual clone methods for dependencies ////////////////////////////////////////////////////////////////////////////// void cloneDependencies(ExecutionPlan* plan, ExecutionNode* theClone, bool withProperties) const; ////////////////////////////////////////////////////////////////////////////// /// @brief convert to a string, basically for debugging purposes ////////////////////////////////////////////////////////////////////////////// virtual void appendAsString(std::string& st, int indent = 0); ////////////////////////////////////////////////////////////////////////////// /// @brief invalidate the cost estimation for the node and its dependencies ////////////////////////////////////////////////////////////////////////////// void invalidateCost(); ////////////////////////////////////////////////////////////////////////////// /// @brief estimate the cost of the node . . . ////////////////////////////////////////////////////////////////////////////// double getCost(size_t& nrItems) const { if (!_estimatedCostSet) { _estimatedCost = estimateCost(_estimatedNrItems); nrItems = _estimatedNrItems; _estimatedCostSet = true; TRI_ASSERT(_estimatedCost >= 0.0); } else { nrItems = _estimatedNrItems; } return _estimatedCost; } ////////////////////////////////////////////////////////////////////////////// /// @brief this actually estimates the costs as well as the number of items /// coming out of the node ////////////////////////////////////////////////////////////////////////////// virtual double estimateCost(size_t& nrItems) const = 0; ////////////////////////////////////////////////////////////////////////////// /// @brief walk a complete execution plan recursively ////////////////////////////////////////////////////////////////////////////// bool walk(WalkerWorker* worker); /////////////////////////////////////////////////////////////////////////////// /// @brief toVelocyPack, export an ExecutionNode to VelocyPack /////////////////////////////////////////////////////////////////////////////// void toVelocyPack(arangodb::velocypack::Builder&, bool) const; ////////////////////////////////////////////////////////////////////////////// /// @brief toVelocyPack ////////////////////////////////////////////////////////////////////////////// virtual void toVelocyPackHelper(arangodb::velocypack::Builder&, bool) const = 0; ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, returning a vector ////////////////////////////////////////////////////////////////////////////// virtual std::vector getVariablesUsedHere() const { return std::vector(); } ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, modifying the set in-place ////////////////////////////////////////////////////////////////////////////// virtual void getVariablesUsedHere( std::unordered_set&) const { // do nothing! } ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesSetHere ////////////////////////////////////////////////////////////////////////////// virtual std::vector getVariablesSetHere() const { return std::vector(); } ////////////////////////////////////////////////////////////////////////////// /// @brief getVariableIdsUsedHere ////////////////////////////////////////////////////////////////////////////// std::unordered_set getVariableIdsUsedHere() const { auto v(getVariablesUsedHere()); std::unordered_set ids; ids.reserve(v.size()); for (auto& it : v) { ids.emplace(it->id); } return ids; } ////////////////////////////////////////////////////////////////////////////// /// @brief setVarsUsedLater ////////////////////////////////////////////////////////////////////////////// void setVarsUsedLater(std::unordered_set& v) { _varsUsedLater = v; } ////////////////////////////////////////////////////////////////////////////// /// @brief getVarsUsedLater, this returns the set of variables that will be /// used later than this node, i.e. in the repeated parents. ////////////////////////////////////////////////////////////////////////////// std::unordered_set const& getVarsUsedLater() const { TRI_ASSERT(_varUsageValid); return _varsUsedLater; } ////////////////////////////////////////////////////////////////////////////// /// @brief setVarsValid ////////////////////////////////////////////////////////////////////////////// void setVarsValid(std::unordered_set& v) { _varsValid = v; } ////////////////////////////////////////////////////////////////////////////// /// @brief getVarsValid, this returns the set of variables that is valid /// for items leaving this node, this includes those that will be set here /// (see getVariablesSetHere). ////////////////////////////////////////////////////////////////////////////// std::unordered_set const& getVarsValid() const { TRI_ASSERT(_varUsageValid); return _varsValid; } ////////////////////////////////////////////////////////////////////////////// /// @brief setVarUsageValid ////////////////////////////////////////////////////////////////////////////// void setVarUsageValid() { _varUsageValid = true; } ////////////////////////////////////////////////////////////////////////////// /// @brief invalidateVarUsage ////////////////////////////////////////////////////////////////////////////// void invalidateVarUsage() { _varsUsedLater.clear(); _varsValid.clear(); _varUsageValid = false; } ////////////////////////////////////////////////////////////////////////////// /// @brief can the node throw? ////////////////////////////////////////////////////////////////////////////// virtual bool canThrow() { return false; } ////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the node is a data modification node ////////////////////////////////////////////////////////////////////////////// virtual bool isModificationNode() const { // derived classes can change this return false; } ////////////////////////////////////////////////////////////////////////////// /// @brief static analysis, walker class and information collector ////////////////////////////////////////////////////////////////////////////// struct VarInfo { unsigned int depth; RegisterId registerId; VarInfo() = delete; VarInfo(int depth, RegisterId registerId) : depth(depth), registerId(registerId) { TRI_ASSERT(registerId < MaxRegisterId); } }; struct RegisterPlan final : public WalkerWorker { // The following are collected for global usage in the ExecutionBlock, // although they are stored here in the node: // map VariableIds to their depth and registerId: std::unordered_map varInfo; // number of variables in the frame of the current depth: std::vector nrRegsHere; // number of variables in this and all outer frames together, // the entry with index i here is always the sum of all values // in nrRegsHere from index 0 to i (inclusively) and the two // have the same length: std::vector nrRegs; // We collect the subquery nodes to deal with them at the end: std::vector subQueryNodes; // Local for the walk: unsigned int depth; unsigned int totalNrRegs; private: // This is used to tell all nodes and share a pointer to ourselves std::shared_ptr* me; public: RegisterPlan() : depth(0), totalNrRegs(0), me(nullptr) { nrRegsHere.emplace_back(0); nrRegs.emplace_back(0); }; void clear(); void setSharedPtr(std::shared_ptr* shared) { me = shared; } // Copy constructor used for a subquery: RegisterPlan(RegisterPlan const& v, unsigned int newdepth); ~RegisterPlan(){}; virtual bool enterSubquery(ExecutionNode*, ExecutionNode*) override final { return false; // do not walk into subquery } virtual void after(ExecutionNode* eb) override final; RegisterPlan* clone(ExecutionPlan* otherPlan, ExecutionPlan* plan); }; ////////////////////////////////////////////////////////////////////////////// /// @brief static analysis ////////////////////////////////////////////////////////////////////////////// void planRegisters(ExecutionNode* super = nullptr); ////////////////////////////////////////////////////////////////////////////// /// @brief get RegisterPlan ////////////////////////////////////////////////////////////////////////////// RegisterPlan const* getRegisterPlan() const { TRI_ASSERT(_registerPlan.get() != nullptr); return _registerPlan.get(); } ////////////////////////////////////////////////////////////////////////////// /// @brief get depth ////////////////////////////////////////////////////////////////////////////// int getDepth() const { return _depth; } ////////////////////////////////////////////////////////////////////////////// /// @brief get registers to clear ////////////////////////////////////////////////////////////////////////////// std::unordered_set const& getRegsToClear() const { return _regsToClear; } ////////////////////////////////////////////////////////////////////////////// /// @brief check if a variable will be used later ////////////////////////////////////////////////////////////////////////////// bool isVarUsedLater(Variable const* variable) const { return (_varsUsedLater.find(variable) != _varsUsedLater.end()); } ////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the node is in an inner loop ////////////////////////////////////////////////////////////////////////////// bool isInInnerLoop() const { return getLoop() != nullptr; } ////////////////////////////////////////////////////////////////////////////// /// @brief get the surrounding loop ////////////////////////////////////////////////////////////////////////////// ExecutionNode const* getLoop() const; protected: ////////////////////////////////////////////////////////////////////////////// /// @brief factory for (optional) variables from json. ////////////////////////////////////////////////////////////////////////////// static Variable* varFromJson(Ast* ast, arangodb::basics::Json const& base, char const* variableName, bool optional = false); ////////////////////////////////////////////////////////////////////////////// /// @brief factory for sort Elements from json. ////////////////////////////////////////////////////////////////////////////// static void getSortElements(SortElementVector& elements, ExecutionPlan* plan, arangodb::basics::Json const& oneNode, char const* which); ////////////////////////////////////////////////////////////////////////////// /// @brief toVelocyPackHelper, for a generic node ////////////////////////////////////////////////////////////////////////////// void toVelocyPackHelperGeneric(arangodb::velocypack::Builder&, bool) const; ////////////////////////////////////////////////////////////////////////////// /// @brief set regs to be deleted ////////////////////////////////////////////////////////////////////////////// void setRegsToClear(std::unordered_set const& toClear) { _regsToClear = toClear; } protected: ////////////////////////////////////////////////////////////////////////////// /// @brief node id ////////////////////////////////////////////////////////////////////////////// size_t const _id; ////////////////////////////////////////////////////////////////////////////// /// @brief our dependent nodes ////////////////////////////////////////////////////////////////////////////// std::vector _dependencies; ////////////////////////////////////////////////////////////////////////////// /// @brief our parent nodes ////////////////////////////////////////////////////////////////////////////// std::vector _parents; ////////////////////////////////////////////////////////////////////////////// /// @brief _estimatedCost = 0 if uninitialized and otherwise stores the result /// of estimateCost(), the bool indicates if the cost has been set, it starts /// out as false, _estimatedNrItems is the estimated number of items coming /// out of this node. ////////////////////////////////////////////////////////////////////////////// double mutable _estimatedCost; size_t mutable _estimatedNrItems; bool mutable _estimatedCostSet; ////////////////////////////////////////////////////////////////////////////// /// @brief _varsUsedLater and _varsValid, the former contains those /// variables that are still needed further down in the chain. The /// latter contains the variables that are set from the dependent nodes /// when an item comes into the current node. Both are only valid if /// _varUsageValid is true. Use ExecutionPlan::findVarUsage to set /// this. ////////////////////////////////////////////////////////////////////////////// std::unordered_set _varsUsedLater; std::unordered_set _varsValid; ////////////////////////////////////////////////////////////////////////////// /// @brief depth of the current frame, will be filled in by planRegisters ////////////////////////////////////////////////////////////////////////////// int _depth; ////////////////////////////////////////////////////////////////////////////// /// @brief whether or not _varsUsedLater and _varsValid are actually valid ////////////////////////////////////////////////////////////////////////////// bool _varUsageValid; ////////////////////////////////////////////////////////////////////////////// /// @brief _plan, the ExecutionPlan object ////////////////////////////////////////////////////////////////////////////// ExecutionPlan* _plan; ////////////////////////////////////////////////////////////////////////////// /// @brief info about variables, filled in by planRegisters ////////////////////////////////////////////////////////////////////////////// std::shared_ptr _registerPlan; ////////////////////////////////////////////////////////////////////////////// /// @brief the following contains the registers which should be cleared /// just before this node hands on results. This is computed during /// the static analysis for each node using the variable usage in the plan. ////////////////////////////////////////////////////////////////////////////// std::unordered_set _regsToClear; public: ////////////////////////////////////////////////////////////////////////////// /// @brief NodeType to string mapping ////////////////////////////////////////////////////////////////////////////// static std::unordered_map const TypeNames; ////////////////////////////////////////////////////////////////////////////// /// @brief maximum register id that can be assigned. /// this is used for assertions ////////////////////////////////////////////////////////////////////////////// static RegisterId const MaxRegisterId; }; //////////////////////////////////////////////////////////////////////////////// /// @brief class SingletonNode //////////////////////////////////////////////////////////////////////////////// class SingletonNode : public ExecutionNode { friend class ExecutionBlock; friend class SingletonBlock; ////////////////////////////////////////////////////////////////////////////// /// @brief constructor with an id ////////////////////////////////////////////////////////////////////////////// public: SingletonNode(ExecutionPlan* plan, size_t id) : ExecutionNode(plan, id) {} SingletonNode(ExecutionPlan*, arangodb::basics::Json const& base); ////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node ////////////////////////////////////////////////////////////////////////////// NodeType getType() const override final { return SINGLETON; } ////////////////////////////////////////////////////////////////////////////// /// @brief export to VelocyPack ////////////////////////////////////////////////////////////////////////////// void toVelocyPackHelper(arangodb::velocypack::Builder&, bool) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively ////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final { auto c = new SingletonNode(plan, _id); cloneHelper(c, plan, withDependencies, withProperties); return static_cast(c); } ////////////////////////////////////////////////////////////////////////////// /// @brief the cost of a singleton is 1 ////////////////////////////////////////////////////////////////////////////// double estimateCost(size_t&) const override final; }; //////////////////////////////////////////////////////////////////////////////// /// @brief class EnumerateCollectionNode //////////////////////////////////////////////////////////////////////////////// class EnumerateCollectionNode : public ExecutionNode { friend class ExecutionNode; friend class ExecutionBlock; friend class EnumerateCollectionBlock; ////////////////////////////////////////////////////////////////////////////// /// @brief constructor with a vocbase and a collection name ////////////////////////////////////////////////////////////////////////////// public: EnumerateCollectionNode(ExecutionPlan* plan, size_t id, TRI_vocbase_t* vocbase, Collection* collection, Variable const* outVariable, bool random) : ExecutionNode(plan, id), _vocbase(vocbase), _collection(collection), _outVariable(outVariable), _random(random) { TRI_ASSERT(_vocbase != nullptr); TRI_ASSERT(_collection != nullptr); TRI_ASSERT(_outVariable != nullptr); } EnumerateCollectionNode(ExecutionPlan* plan, arangodb::basics::Json const& base); ////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node ////////////////////////////////////////////////////////////////////////////// NodeType getType() const override final { return ENUMERATE_COLLECTION; } ////////////////////////////////////////////////////////////////////////////// /// @brief export to VelocyPack ////////////////////////////////////////////////////////////////////////////// void toVelocyPackHelper(arangodb::velocypack::Builder&, bool) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively ////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief the cost of an enumerate collection node is a multiple of the cost /// of /// its unique dependency ////////////////////////////////////////////////////////////////////////////// double estimateCost(size_t&) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesSetHere ////////////////////////////////////////////////////////////////////////////// std::vector getVariablesSetHere() const override final { return std::vector{_outVariable}; } ////////////////////////////////////////////////////////////////////////////// /// @brief enable random iteration of documents in collection ////////////////////////////////////////////////////////////////////////////// void setRandom() { _random = true; } ////////////////////////////////////////////////////////////////////////////// /// @brief return the database ////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* vocbase() const { return _vocbase; } ////////////////////////////////////////////////////////////////////////////// /// @brief return the collection ////////////////////////////////////////////////////////////////////////////// Collection const* collection() const { return _collection; } ////////////////////////////////////////////////////////////////////////////// /// @brief return the out variable ////////////////////////////////////////////////////////////////////////////// Variable const* outVariable() const { return _outVariable; } private: ////////////////////////////////////////////////////////////////////////////// /// @brief the database ////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* _vocbase; ////////////////////////////////////////////////////////////////////////////// /// @brief collection ////////////////////////////////////////////////////////////////////////////// Collection* _collection; ////////////////////////////////////////////////////////////////////////////// /// @brief output variable ////////////////////////////////////////////////////////////////////////////// Variable const* _outVariable; ////////////////////////////////////////////////////////////////////////////// /// @brief whether or not we want random iteration ////////////////////////////////////////////////////////////////////////////// bool _random; }; //////////////////////////////////////////////////////////////////////////////// /// @brief class EnumerateListNode //////////////////////////////////////////////////////////////////////////////// class EnumerateListNode : public ExecutionNode { friend class ExecutionNode; friend class ExecutionBlock; friend class EnumerateListBlock; friend class RedundantCalculationsReplacer; public: EnumerateListNode(ExecutionPlan* plan, size_t id, Variable const* inVariable, Variable const* outVariable) : ExecutionNode(plan, id), _inVariable(inVariable), _outVariable(outVariable) { TRI_ASSERT(_inVariable != nullptr); TRI_ASSERT(_outVariable != nullptr); } EnumerateListNode(ExecutionPlan*, arangodb::basics::Json const& base); ////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node ////////////////////////////////////////////////////////////////////////////// NodeType getType() const override final { return ENUMERATE_LIST; } ////////////////////////////////////////////////////////////////////////////// /// @brief export to VelocyPack ////////////////////////////////////////////////////////////////////////////// void toVelocyPackHelper(arangodb::velocypack::Builder&, bool) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively ////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief the cost of an enumerate list node ////////////////////////////////////////////////////////////////////////////// double estimateCost(size_t&) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, returning a vector ////////////////////////////////////////////////////////////////////////////// std::vector getVariablesUsedHere() const override final { return std::vector{_inVariable}; } ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, modifying the set in-place ////////////////////////////////////////////////////////////////////////////// void getVariablesUsedHere( std::unordered_set& vars) const override final { vars.emplace(_inVariable); } ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesSetHere ////////////////////////////////////////////////////////////////////////////// std::vector getVariablesSetHere() const override final { return std::vector{_outVariable}; } ////////////////////////////////////////////////////////////////////////////// /// @brief return in variable ////////////////////////////////////////////////////////////////////////////// Variable const* inVariable() const { return _inVariable; } ////////////////////////////////////////////////////////////////////////////// /// @brief return out variable ////////////////////////////////////////////////////////////////////////////// Variable const* outVariable() const { return _outVariable; } private: ////////////////////////////////////////////////////////////////////////////// /// @brief input variable to read from ////////////////////////////////////////////////////////////////////////////// Variable const* _inVariable; ////////////////////////////////////////////////////////////////////////////// /// @brief output variable to write to ////////////////////////////////////////////////////////////////////////////// Variable const* _outVariable; }; //////////////////////////////////////////////////////////////////////////////// /// @brief class LimitNode //////////////////////////////////////////////////////////////////////////////// class LimitNode : public ExecutionNode { friend class ExecutionBlock; friend class LimitBlock; ////////////////////////////////////////////////////////////////////////////// /// @brief constructors for various arguments, always with offset and limit ////////////////////////////////////////////////////////////////////////////// public: LimitNode(ExecutionPlan* plan, size_t id, size_t offset, size_t limit) : ExecutionNode(plan, id), _offset(offset), _limit(limit), _fullCount(false) {} LimitNode(ExecutionPlan* plan, size_t id, size_t limit) : ExecutionNode(plan, id), _offset(0), _limit(limit), _fullCount(false) {} LimitNode(ExecutionPlan*, arangodb::basics::Json const& base); ////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node ////////////////////////////////////////////////////////////////////////////// NodeType getType() const override final { return LIMIT; } ////////////////////////////////////////////////////////////////////////////// /// @brief export to VelocyPack ////////////////////////////////////////////////////////////////////////////// void toVelocyPackHelper(arangodb::velocypack::Builder&, bool) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively ////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final { auto c = new LimitNode(plan, _id, _offset, _limit); if (_fullCount) { c->setFullCount(); } cloneHelper(c, plan, withDependencies, withProperties); return static_cast(c); } ////////////////////////////////////////////////////////////////////////////// /// @brief estimateCost ////////////////////////////////////////////////////////////////////////////// double estimateCost(size_t&) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief tell the node to fully count what it will limit ////////////////////////////////////////////////////////////////////////////// void setFullCount() { _fullCount = true; } ////////////////////////////////////////////////////////////////////////////// /// @brief return the offset value ////////////////////////////////////////////////////////////////////////////// size_t offset() const { return _offset; } ////////////////////////////////////////////////////////////////////////////// /// @brief return the limit value ////////////////////////////////////////////////////////////////////////////// size_t limit() const { return _limit; } private: ////////////////////////////////////////////////////////////////////////////// /// @brief the offset ////////////////////////////////////////////////////////////////////////////// size_t _offset; ////////////////////////////////////////////////////////////////////////////// /// @brief the limit ////////////////////////////////////////////////////////////////////////////// size_t _limit; ////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the node should fully count what it limits ////////////////////////////////////////////////////////////////////////////// bool _fullCount; }; //////////////////////////////////////////////////////////////////////////////// /// @brief class CalculationNode //////////////////////////////////////////////////////////////////////////////// class CalculationNode : public ExecutionNode { friend class ExecutionNode; friend class ExecutionBlock; friend class CalculationBlock; friend class RedundantCalculationsReplacer; public: CalculationNode(ExecutionPlan* plan, size_t id, Expression* expr, Variable const* conditionVariable, Variable const* outVariable) : ExecutionNode(plan, id), _conditionVariable(conditionVariable), _outVariable(outVariable), _expression(expr), _canRemoveIfThrows(false) { TRI_ASSERT(_expression != nullptr); TRI_ASSERT(_outVariable != nullptr); } CalculationNode(ExecutionPlan* plan, size_t id, Expression* expr, Variable const* outVariable) : CalculationNode(plan, id, expr, nullptr, outVariable) {} CalculationNode(ExecutionPlan*, arangodb::basics::Json const& base); ~CalculationNode() { delete _expression; } ////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node ////////////////////////////////////////////////////////////////////////////// NodeType getType() const override final { return CALCULATION; } ////////////////////////////////////////////////////////////////////////////// /// @brief export to VelocyPack ////////////////////////////////////////////////////////////////////////////// void toVelocyPackHelper(arangodb::velocypack::Builder&, bool) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively ////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief return out variable ////////////////////////////////////////////////////////////////////////////// Variable const* outVariable() const { return _outVariable; } ////////////////////////////////////////////////////////////////////////////// /// @brief return the expression ////////////////////////////////////////////////////////////////////////////// Expression* expression() const { return _expression; } ////////////////////////////////////////////////////////////////////////////// /// @brief allow removal of this calculation even if it can throw /// this can only happen if the optimizer added a clone of this expression /// elsewhere, and if the clone will stand in ////////////////////////////////////////////////////////////////////////////// bool canRemoveIfThrows() const { return _canRemoveIfThrows; } ////////////////////////////////////////////////////////////////////////////// /// @brief allow removal of this calculation even if it can throw /// this can only happen if the optimizer added a clone of this expression /// elsewhere, and if the clone will stand in ////////////////////////////////////////////////////////////////////////////// void canRemoveIfThrows(bool value) { _canRemoveIfThrows = value; } ////////////////////////////////////////////////////////////////////////////// /// @brief estimateCost ////////////////////////////////////////////////////////////////////////////// double estimateCost(size_t&) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, returning a vector ////////////////////////////////////////////////////////////////////////////// std::vector getVariablesUsedHere() const override final { std::unordered_set vars; _expression->variables(vars); std::vector v; v.reserve(vars.size()); for (auto const& vv : vars) { v.emplace_back(vv); } if (_conditionVariable != nullptr) { v.emplace_back(_conditionVariable); } return v; } ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, modifying the set in-place ////////////////////////////////////////////////////////////////////////////// void getVariablesUsedHere( std::unordered_set& vars) const override final { _expression->variables(vars); if (_conditionVariable != nullptr) { vars.emplace(_conditionVariable); } } ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesSetHere ////////////////////////////////////////////////////////////////////////////// virtual std::vector getVariablesSetHere() const override final { return std::vector{_outVariable}; } ////////////////////////////////////////////////////////////////////////////// /// @brief can the node throw? ////////////////////////////////////////////////////////////////////////////// bool canThrow() override { return _expression->canThrow(); } private: ////////////////////////////////////////////////////////////////////////////// /// @brief an optional condition variable for the calculation ////////////////////////////////////////////////////////////////////////////// Variable const* _conditionVariable; ////////////////////////////////////////////////////////////////////////////// /// @brief output variable to write to ////////////////////////////////////////////////////////////////////////////// Variable const* _outVariable; ////////////////////////////////////////////////////////////////////////////// /// @brief we need to have an expression and where to write the result ////////////////////////////////////////////////////////////////////////////// Expression* _expression; ////////////////////////////////////////////////////////////////////////////// /// @brief allow removal of this calculation even if it can throw /// this can only happen if the optimizer added a clone of this expression /// elsewhere, and if the clone will stand in ////////////////////////////////////////////////////////////////////////////// bool _canRemoveIfThrows; }; //////////////////////////////////////////////////////////////////////////////// /// @brief class SubqueryNode //////////////////////////////////////////////////////////////////////////////// class SubqueryNode : public ExecutionNode { friend class ExecutionNode; friend class ExecutionBlock; friend class SubqueryBlock; public: SubqueryNode(ExecutionPlan*, arangodb::basics::Json const& base); SubqueryNode(ExecutionPlan* plan, size_t id, ExecutionNode* subquery, Variable const* outVariable) : ExecutionNode(plan, id), _subquery(subquery), _outVariable(outVariable) { TRI_ASSERT(_subquery != nullptr); TRI_ASSERT(_outVariable != nullptr); } ////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node ////////////////////////////////////////////////////////////////////////////// NodeType getType() const override final { return SUBQUERY; } ////////////////////////////////////////////////////////////////////////////// /// @brief return the out variable ////////////////////////////////////////////////////////////////////////////// Variable const* outVariable() const { return _outVariable; } ////////////////////////////////////////////////////////////////////////////// /// @brief export to VelocyPack ////////////////////////////////////////////////////////////////////////////// void toVelocyPackHelper(arangodb::velocypack::Builder&, bool) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively ////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the subquery is a data-modification operation ////////////////////////////////////////////////////////////////////////////// bool isModificationQuery() const; ////////////////////////////////////////////////////////////////////////////// /// @brief getter for subquery ////////////////////////////////////////////////////////////////////////////// ExecutionNode* getSubquery() const { return _subquery; } ////////////////////////////////////////////////////////////////////////////// /// @brief setter for subquery ////////////////////////////////////////////////////////////////////////////// void setSubquery(ExecutionNode* subquery, bool forceOverwrite) { TRI_ASSERT(subquery != nullptr); TRI_ASSERT((forceOverwrite && _subquery != nullptr) || (!forceOverwrite && _subquery == nullptr)); _subquery = subquery; } ////////////////////////////////////////////////////////////////////////////// /// @brief estimateCost ////////////////////////////////////////////////////////////////////////////// double estimateCost(size_t&) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, returning a vector ////////////////////////////////////////////////////////////////////////////// std::vector getVariablesUsedHere() const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, modifying the set in-place ////////////////////////////////////////////////////////////////////////////// void getVariablesUsedHere( std::unordered_set& vars) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesSetHere ////////////////////////////////////////////////////////////////////////////// std::vector getVariablesSetHere() const override final { return std::vector{_outVariable}; } ////////////////////////////////////////////////////////////////////////////// /// @brief replace the out variable, so we can adjust the name. ////////////////////////////////////////////////////////////////////////////// void replaceOutVariable(Variable const* var); ////////////////////////////////////////////////////////////////////////////// /// @brief can the node throw? Note that this means that an exception can /// *originate* from this node. That is, this method does not need to /// return true just because a dependent node can throw an exception. ////////////////////////////////////////////////////////////////////////////// bool canThrow() override; private: ////////////////////////////////////////////////////////////////////////////// /// @brief we need to have an expression and where to write the result ////////////////////////////////////////////////////////////////////////////// ExecutionNode* _subquery; ////////////////////////////////////////////////////////////////////////////// /// @brief variable to write to ////////////////////////////////////////////////////////////////////////////// Variable const* _outVariable; }; //////////////////////////////////////////////////////////////////////////////// /// @brief class FilterNode //////////////////////////////////////////////////////////////////////////////// class FilterNode : public ExecutionNode { friend class ExecutionBlock; friend class FilterBlock; friend class RedundantCalculationsReplacer; ////////////////////////////////////////////////////////////////////////////// /// @brief constructors for various arguments, always with offset and limit ////////////////////////////////////////////////////////////////////////////// public: FilterNode(ExecutionPlan* plan, size_t id, Variable const* inVariable) : ExecutionNode(plan, id), _inVariable(inVariable) { TRI_ASSERT(_inVariable != nullptr); } FilterNode(ExecutionPlan*, arangodb::basics::Json const& base); ////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node ////////////////////////////////////////////////////////////////////////////// NodeType getType() const override final { return FILTER; } ////////////////////////////////////////////////////////////////////////////// /// @brief export to VelocyPack ////////////////////////////////////////////////////////////////////////////// void toVelocyPackHelper(arangodb::velocypack::Builder&, bool) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively ////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief estimateCost ////////////////////////////////////////////////////////////////////////////// double estimateCost(size_t&) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, returning a vector ////////////////////////////////////////////////////////////////////////////// std::vector getVariablesUsedHere() const override final { return std::vector{_inVariable}; } ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, modifying the set in-place ////////////////////////////////////////////////////////////////////////////// void getVariablesUsedHere( std::unordered_set& vars) const override final { vars.emplace(_inVariable); } private: ////////////////////////////////////////////////////////////////////////////// /// @brief input variable to read from ////////////////////////////////////////////////////////////////////////////// Variable const* _inVariable; }; //////////////////////////////////////////////////////////////////////////////// /// @brief this is an auxilliary struct for processed sort criteria information //////////////////////////////////////////////////////////////////////////////// struct SortInformation { enum Match { unequal, // criteria are unequal otherLessAccurate, // leftmost sort criteria are equal, but other sort // criteria are less accurate than ourselves ourselvesLessAccurate, // leftmost sort criteria are equal, but our own // sort criteria is less accurate than the other allEqual // all criteria are equal }; std::vector> criteria; bool isValid = true; bool isDeterministic = true; bool isComplex = false; bool canThrow = false; Match isCoveredBy(SortInformation const& other) { if (!isValid || !other.isValid) { return unequal; } if (isComplex || other.isComplex) { return unequal; } size_t const n = criteria.size(); for (size_t i = 0; i < n; ++i) { if (other.criteria.size() <= i) { return otherLessAccurate; } auto ours = criteria[i]; auto theirs = other.criteria[i]; if (std::get<2>(ours) != std::get<2>(theirs)) { // sort order is different return unequal; } if (std::get<1>(ours) != std::get<1>(theirs)) { // sort criterion is different return unequal; } } if (other.criteria.size() > n) { return ourselvesLessAccurate; } return allEqual; } }; //////////////////////////////////////////////////////////////////////////////// /// @brief class ReturnNode //////////////////////////////////////////////////////////////////////////////// class ReturnNode : public ExecutionNode { friend class ExecutionBlock; friend class ReturnBlock; friend class RedundantCalculationsReplacer; ////////////////////////////////////////////////////////////////////////////// /// @brief constructors for various arguments, always with offset and limit ////////////////////////////////////////////////////////////////////////////// public: ReturnNode(ExecutionPlan* plan, size_t id, Variable const* inVariable) : ExecutionNode(plan, id), _inVariable(inVariable) { TRI_ASSERT(_inVariable != nullptr); } ReturnNode(ExecutionPlan*, arangodb::basics::Json const& base); ////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node ////////////////////////////////////////////////////////////////////////////// NodeType getType() const override final { return RETURN; } ////////////////////////////////////////////////////////////////////////////// /// @brief export to VelocyPack ////////////////////////////////////////////////////////////////////////////// void toVelocyPackHelper(arangodb::velocypack::Builder&, bool) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively ////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief estimateCost ////////////////////////////////////////////////////////////////////////////// double estimateCost(size_t&) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, returning a vector ////////////////////////////////////////////////////////////////////////////// std::vector getVariablesUsedHere() const override final { return std::vector{_inVariable}; } ////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, modifying the set in-place ////////////////////////////////////////////////////////////////////////////// void getVariablesUsedHere( std::unordered_set& vars) const override final { vars.emplace(_inVariable); } Variable const* inVariable() const { return _inVariable; } private: ////////////////////////////////////////////////////////////////////////////// /// @brief we need to know the offset and limit ////////////////////////////////////////////////////////////////////////////// Variable const* _inVariable; }; //////////////////////////////////////////////////////////////////////////////// /// @brief class NoResultsNode //////////////////////////////////////////////////////////////////////////////// class NoResultsNode : public ExecutionNode { friend class ExecutionBlock; friend class NoResultsBlock; ////////////////////////////////////////////////////////////////////////////// /// @brief constructor with an id ////////////////////////////////////////////////////////////////////////////// public: NoResultsNode(ExecutionPlan* plan, size_t id) : ExecutionNode(plan, id) {} NoResultsNode(ExecutionPlan* plan, arangodb::basics::Json const& base) : ExecutionNode(plan, base) {} ////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node ////////////////////////////////////////////////////////////////////////////// NodeType getType() const override final { return NORESULTS; } ////////////////////////////////////////////////////////////////////////////// /// @brief export to VelocyPack ////////////////////////////////////////////////////////////////////////////// void toVelocyPackHelper(arangodb::velocypack::Builder&, bool) const override final; ////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively ////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final { auto c = new NoResultsNode(plan, _id); cloneHelper(c, plan, withDependencies, withProperties); return static_cast(c); } ////////////////////////////////////////////////////////////////////////////// /// @brief the cost of a NoResults is 0 ////////////////////////////////////////////////////////////////////////////// double estimateCost(size_t&) const override final; }; } // namespace arangodb::aql } // namespace arangodb #endif