//////////////////////////////////////////////////////////////////////////////// /// @brief Infrastructure for ExecutionPlans /// /// @file arangod/Aql/ExecutionNode.h /// /// DISCLAIMER /// /// Copyright 2010-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 triAGENS GmbH, Cologne, Germany /// /// @author Max Neunhoeffer /// @author Copyright 2014, triagens GmbH, Cologne, Germany //////////////////////////////////////////////////////////////////////////////// #ifndef ARANGODB_AQL_EXECUTION_NODE_H #define ARANGODB_AQL_EXECUTION_NODE_H 1 #include "Basics/Common.h" #include "Aql/AggregationOptions.h" #include "Aql/Ast.h" #include "Aql/Collection.h" #include "Aql/Expression.h" #include "Aql/Index.h" #include "Aql/ModificationOptions.h" #include "Aql/Query.h" #include "Aql/RangeInfo.h" #include "Aql/Range.h" #include "Aql/types.h" #include "Aql/Variable.h" #include "Aql/WalkerWorker.h" #include "Basics/JsonHelper.h" #include "lib/Basics/json-utilities.h" #include "VocBase/voc-types.h" #include "VocBase/vocbase.h" namespace triagens { namespace basics { class StringBuffer; } namespace aql { class Ast; class ExecutionBlock; class ExecutionPlan; 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; public: enum NodeType : int { ILLEGAL = 0, SINGLETON = 1, ENUMERATE_COLLECTION = 2, INDEX_RANGE = 3, ENUMERATE_LIST = 4, FILTER = 5, LIMIT = 6, CALCULATION = 7, SUBQUERY = 8, SORT = 9, AGGREGATE = 10, SCATTER = 11, GATHER = 12, REMOTE = 13, INSERT = 14, REMOVE = 15, REPLACE = 16, UPDATE = 17, RETURN = 18, NORESULTS = 19, DISTRIBUTE = 20, UPSERT = 21 }; // ----------------------------------------------------------------------------- // --SECTION-- constructors / destructors // ----------------------------------------------------------------------------- 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, triagens::basics::Json const& json); //////////////////////////////////////////////////////////////////////////////// /// @brief destructor, free dependencies; //////////////////////////////////////////////////////////////////////////////// virtual ~ExecutionNode () { } // ----------------------------------------------------------------------------- // --SECTION-- public methods // ----------------------------------------------------------------------------- public: //////////////////////////////////////////////////////////////////////////////// /// @brief factory from json. //////////////////////////////////////////////////////////////////////////////// static ExecutionNode* fromJsonFactory (ExecutionPlan* plan, triagens::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 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 add the node parents to a vector //////////////////////////////////////////////////////////////////////////////// void addParents (std::vector& result) const { for (auto const& it : _parents) { result.emplace_back(it); } } //////////////////////////////////////////////////////////////////////////////// /// @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 inspect one index; only skiplist indexes which match attrs in sequence. /// @returns a qualification how good they match; /// match->index==nullptr means no match at all. //////////////////////////////////////////////////////////////////////////////// static IndexMatch CompareIndex (ExecutionNode const*, Index const*, IndexMatchVec const&); //////////////////////////////////////////////////////////////////////////////// /// @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 { _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 () { _estimatedCostSet = false; for (auto& dep : _dependencies) { dep->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 export to JSON, returns an AUTOFREE Json object //////////////////////////////////////////////////////////////////////////////// triagens::basics::Json toJson (TRI_memory_zone_t*, bool) const; //////////////////////////////////////////////////////////////////////////////// /// @brief toJson //////////////////////////////////////////////////////////////////////////////// virtual void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, 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 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()); } // ----------------------------------------------------------------------------- // --SECTION-- protected functions // ----------------------------------------------------------------------------- protected: //////////////////////////////////////////////////////////////////////////////// /// @brief factory for (optional) variables from json. //////////////////////////////////////////////////////////////////////////////// static Variable* varFromJson (Ast* ast, triagens::basics::Json const& base, char const* variableName, bool optional = false); //////////////////////////////////////////////////////////////////////////////// /// @brief factory for sort Elements from json. //////////////////////////////////////////////////////////////////////////////// static void getSortElements (SortElementVector& elements, ExecutionPlan* plan, triagens::basics::Json const& oneNode, char const* which); //////////////////////////////////////////////////////////////////////////////// /// @brief toJsonHelper, for a generic node //////////////////////////////////////////////////////////////////////////////// triagens::basics::Json toJsonHelperGeneric (triagens::basics::Json&, TRI_memory_zone_t*, bool) const; //////////////////////////////////////////////////////////////////////////////// /// @brief set regs to be deleted //////////////////////////////////////////////////////////////////////////////// void setRegsToClear (std::unordered_set const& toClear) { _regsToClear = toClear; } // ----------------------------------------------------------------------------- // --SECTION-- protected variables // ----------------------------------------------------------------------------- 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 uninitialised 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; // ----------------------------------------------------------------------------- // --SECTION-- public static variables // ----------------------------------------------------------------------------- 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; }; // ----------------------------------------------------------------------------- // --SECTION-- class SingletonNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @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*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return SINGLETON; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, 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; }; // ----------------------------------------------------------------------------- // --SECTION-- class EnumerateCollectionNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @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, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return ENUMERATE_COLLECTION; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, 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 get the number of usable fields from the index (according to the /// attributes passed) //////////////////////////////////////////////////////////////////////////////// size_t getUsableFieldsOfIndex (Index const* idx, std::unordered_set const&) const; //////////////////////////////////////////////////////////////////////////////// /// @brief get vector of indices that has any match in its fields with //////////////////////////////////////////////////////////////////////////////// void getIndexesForIndexRangeNode (std::unordered_set const& attrs, std::vector& idxs, std::vector& prefixes) const; //////////////////////////////////////////////////////////////////////////////// /// @brief get vector of skiplist indices which match attrs in sequence. /// @returns a list of indexes with a qualification how good they match /// the specified indexes. //////////////////////////////////////////////////////////////////////////////// std::vector getIndicesOrdered (IndexMatchVec const& attrs) const; //////////////////////////////////////////////////////////////////////////////// /// @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; } // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- 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; }; // ----------------------------------------------------------------------------- // --SECTION-- class EnumerateListNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class EnumerateListNode //////////////////////////////////////////////////////////////////////////////// class EnumerateListNode : public ExecutionNode { friend class ExecutionNode; friend class ExecutionBlock; friend class EnumerateListBlock; friend class RedundantCalculationsReplacer; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor //////////////////////////////////////////////////////////////////////////////// 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*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return ENUMERATE_LIST; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, 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 }; } // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief input variable to read from //////////////////////////////////////////////////////////////////////////////// Variable const* _inVariable; //////////////////////////////////////////////////////////////////////////////// /// @brief output variable to write to //////////////////////////////////////////////////////////////////////////////// Variable const* _outVariable; }; //////////////////////////////////////////////////////////////////////////////// /// @brief class IndexRangeNode //////////////////////////////////////////////////////////////////////////////// class IndexRangeNode: public ExecutionNode { friend class ExecutionBlock; friend class IndexRangeBlock; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor with a vocbase and a collection name //////////////////////////////////////////////////////////////////////////////// // _ranges must correspond to a prefix of the fields of the index , i.e. // _ranges.at(i) is a range of values for idx->_fields._buffer[i]. public: IndexRangeNode (ExecutionPlan* plan, size_t id, TRI_vocbase_t* vocbase, Collection const* collection, Variable const* outVariable, Index const* index, std::vector> const& ranges, bool reverse) : ExecutionNode(plan, id), _vocbase(vocbase), _collection(collection), _outVariable(outVariable), _index(index), _ranges(ranges), _reverse(reverse) { TRI_ASSERT(_vocbase != nullptr); TRI_ASSERT(_collection != nullptr); TRI_ASSERT(_outVariable != nullptr); TRI_ASSERT(_index != nullptr); } IndexRangeNode (ExecutionPlan*, triagens::basics::Json const& base); ~IndexRangeNode () { } //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return INDEX_RANGE; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the database //////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* vocbase () const { return _vocbase; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the collection //////////////////////////////////////////////////////////////////////////////// Collection const* collection () const { return _collection; } //////////////////////////////////////////////////////////////////////////////// /// @brief return out variable //////////////////////////////////////////////////////////////////////////////// Variable const* outVariable () const { return _outVariable; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the ranges //////////////////////////////////////////////////////////////////////////////// std::vector> const& ranges () const { return _ranges; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, bool) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone (ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesSetHere //////////////////////////////////////////////////////////////////////////////// std::vector getVariablesSetHere () const override final { return std::vector{ _outVariable }; } //////////////////////////////////////////////////////////////////////////////// /// @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 estimateCost //////////////////////////////////////////////////////////////////////////////// double estimateCost (size_t&) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief check whether the pattern matches this node's index //////////////////////////////////////////////////////////////////////////////// IndexMatch matchesIndex (IndexMatchVec const& pattern) const; //////////////////////////////////////////////////////////////////////////////// /// @brief whether or not a reverse index traversal is used //////////////////////////////////////////////////////////////////////////////// void reverse (bool value) { _reverse = value; } //////////////////////////////////////////////////////////////////////////////// /// @brief getIndex, hand out the index used //////////////////////////////////////////////////////////////////////////////// Index const* getIndex () { return _index; } // ----------------------------------------------------------------------------- // --SECTION-- private methods // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief provide an estimate for the number of items, using the index /// selectivity info (if present) //////////////////////////////////////////////////////////////////////////////// bool estimateItemsWithIndexSelectivity (size_t, size_t&) const; // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief the database //////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* _vocbase; //////////////////////////////////////////////////////////////////////////////// /// @brief collection //////////////////////////////////////////////////////////////////////////////// Collection const* _collection; //////////////////////////////////////////////////////////////////////////////// /// @brief output variable //////////////////////////////////////////////////////////////////////////////// Variable const* _outVariable; //////////////////////////////////////////////////////////////////////////////// /// @brief the index //////////////////////////////////////////////////////////////////////////////// Index const* _index; //////////////////////////////////////////////////////////////////////////////// /// @brief the range info //////////////////////////////////////////////////////////////////////////////// std::vector> _ranges; //////////////////////////////////////////////////////////////////////////////// /// @brief use a reverse index scan //////////////////////////////////////////////////////////////////////////////// bool _reverse; }; // ----------------------------------------------------------------------------- // --SECTION-- class LimitNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @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*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return LIMIT; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, 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; } 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; }; // ----------------------------------------------------------------------------- // --SECTION-- class CalculationNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class CalculationNode //////////////////////////////////////////////////////////////////////////////// class CalculationNode : public ExecutionNode { friend class ExecutionNode; friend class ExecutionBlock; friend class CalculationBlock; friend class RedundantCalculationsReplacer; public: //////////////////////////////////////////////////////////////////////////////// /// @brief constructor //////////////////////////////////////////////////////////////////////////////// CalculationNode (ExecutionPlan* plan, size_t id, Expression* expr, Variable const* conditionVariable, Variable const* outVariable) : ExecutionNode(plan, id), _conditionVariable(conditionVariable), _outVariable(outVariable), _expression(expr) { TRI_ASSERT(_expression != nullptr); TRI_ASSERT(_outVariable != nullptr); } //////////////////////////////////////////////////////////////////////////////// /// @brief constructor //////////////////////////////////////////////////////////////////////////////// CalculationNode (ExecutionPlan* plan, size_t id, Expression* expr, Variable const* outVariable) : CalculationNode(plan, id, expr, nullptr, outVariable) { } CalculationNode (ExecutionPlan*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief destructor //////////////////////////////////////////////////////////////////////////////// ~CalculationNode () { delete _expression; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return CALCULATION; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, 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 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(); } // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- 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; }; // ----------------------------------------------------------------------------- // --SECTION-- class SubqueryNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class SubqueryNode //////////////////////////////////////////////////////////////////////////////// class SubqueryNode : public ExecutionNode { friend class ExecutionNode; friend class ExecutionBlock; friend class SubqueryBlock; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor //////////////////////////////////////////////////////////////////////////////// public: SubqueryNode (ExecutionPlan*, triagens::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 JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, bool) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone (ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief getter for subquery //////////////////////////////////////////////////////////////////////////////// ExecutionNode* getSubquery () const { return _subquery; } //////////////////////////////////////////////////////////////////////////////// /// @brief setter for subquery //////////////////////////////////////////////////////////////////////////////// void setSubquery (ExecutionNode* subquery) { TRI_ASSERT(subquery != nullptr); TRI_ASSERT(_subquery == nullptr); // do not allow overwriting an existing subquery _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; // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief we need to have an expression and where to write the result //////////////////////////////////////////////////////////////////////////////// ExecutionNode* _subquery; //////////////////////////////////////////////////////////////////////////////// /// @brief variable to write to //////////////////////////////////////////////////////////////////////////////// Variable const* _outVariable; }; // ----------------------------------------------------------------------------- // --SECTION-- class FilterNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @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*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return FILTER; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, 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; }; // ----------------------------------------------------------------------------- // --SECTION-- struct SortInformation // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @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; } }; // ----------------------------------------------------------------------------- // --SECTION-- class SortNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class SortNode //////////////////////////////////////////////////////////////////////////////// class SortNode : public ExecutionNode { friend class ExecutionBlock; friend class SortBlock; friend class RedundantCalculationsReplacer; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor //////////////////////////////////////////////////////////////////////////////// public: SortNode (ExecutionPlan* plan, size_t id, SortElementVector const& elements, bool stable) : ExecutionNode(plan, id), _elements(elements), _stable(stable) { } SortNode (ExecutionPlan* plan, triagens::basics::Json const& base, SortElementVector const& elements, bool stable); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return SORT; } //////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the sort is stable //////////////////////////////////////////////////////////////////////////////// inline bool isStable () const { return _stable; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, bool) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone (ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final { auto c = new SortNode(plan, _id, _elements, _stable); cloneHelper(c, plan, withDependencies, withProperties); return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// /// @brief estimateCost //////////////////////////////////////////////////////////////////////////////// double estimateCost (size_t&) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, returning a vector //////////////////////////////////////////////////////////////////////////////// std::vector getVariablesUsedHere () const override final { std::vector v; v.reserve(_elements.size()); for (auto& p : _elements) { v.emplace_back(p.first); } return v; } //////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, modifying the set in-place //////////////////////////////////////////////////////////////////////////////// void getVariablesUsedHere (std::unordered_set& vars) const override final { for (auto& p : _elements) { vars.emplace(p.first); } } //////////////////////////////////////////////////////////////////////////////// /// @brief get Variables Used Here including ASC/DESC //////////////////////////////////////////////////////////////////////////////// SortElementVector const& getElements () const { return _elements; } //////////////////////////////////////////////////////////////////////////////// /// @brief returns all sort information //////////////////////////////////////////////////////////////////////////////// SortInformation getSortInformation (ExecutionPlan*, triagens::basics::StringBuffer*) const; std::vector> getCalcNodePairs (); //////////////////////////////////////////////////////////////////////////////// /// @brief simplifies the expressions of the sort node /// this will sort expressions if they are constant /// the method will return true if all sort expressions were removed after /// simplification, and false otherwise //////////////////////////////////////////////////////////////////////////////// bool simplify (ExecutionPlan*); // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief pairs, consisting of variable and sort direction /// (true = ascending | false = descending) //////////////////////////////////////////////////////////////////////////////// SortElementVector _elements; //////////////////////////////////////////////////////////////////////////////// /// whether or not the sort is stable //////////////////////////////////////////////////////////////////////////////// bool _stable; }; // ----------------------------------------------------------------------------- // --SECTION-- class AggregateNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class AggregateNode //////////////////////////////////////////////////////////////////////////////// class AggregateNode : public ExecutionNode { friend class ExecutionNode; friend class ExecutionBlock; friend class SortedAggregateBlock; friend class HashedAggregateBlock; friend class RedundantCalculationsReplacer; public: //////////////////////////////////////////////////////////////////////////////// /// @brief constructor //////////////////////////////////////////////////////////////////////////////// public: AggregateNode (ExecutionPlan* plan, size_t id, AggregationOptions const& options, std::vector> const& aggregateVariables, Variable const* expressionVariable, Variable const* outVariable, std::vector const& keepVariables, std::unordered_map const& variableMap, bool count, bool isDistinctCommand) : ExecutionNode(plan, id), _options(options), _aggregateVariables(aggregateVariables), _expressionVariable(expressionVariable), _outVariable(outVariable), _keepVariables(keepVariables), _variableMap(variableMap), _count(count), _isDistinctCommand(isDistinctCommand), _specialized(false) { // outVariable can be a nullptr, but only if _count is not set TRI_ASSERT(! _count || _outVariable != nullptr); } AggregateNode (ExecutionPlan*, triagens::basics::Json const& base, Variable const* expressionVariable, Variable const* outVariable, std::vector const& keepVariables, std::unordered_map const& variableMap, std::vector> const& aggregateVariables, bool count, bool isDistinctCommand); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return AGGREGATE; } //////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the node requires an additional post SORT //////////////////////////////////////////////////////////////////////////////// bool isDistinctCommand () const { return _isDistinctCommand; } //////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the node is specialized //////////////////////////////////////////////////////////////////////////////// bool isSpecialized () const { return _specialized; } //////////////////////////////////////////////////////////////////////////////// /// @brief specialize the node //////////////////////////////////////////////////////////////////////////////// void specialized () { _specialized = true; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the aggregation method //////////////////////////////////////////////////////////////////////////////// AggregationOptions::AggregationMethod aggregationMethod () const { return _options.method; } //////////////////////////////////////////////////////////////////////////////// /// @brief set the aggregation method //////////////////////////////////////////////////////////////////////////////// void aggregationMethod (AggregationOptions::AggregationMethod method) { _options.method = method; } //////////////////////////////////////////////////////////////////////////////// /// @brief getOptions //////////////////////////////////////////////////////////////////////////////// AggregationOptions const& getOptions () const { return _options; } //////////////////////////////////////////////////////////////////////////////// /// @brief getOptions //////////////////////////////////////////////////////////////////////////////// AggregationOptions& getOptions () { return _options; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, 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 whether or not the count flag is set //////////////////////////////////////////////////////////////////////////////// inline bool count () const { return _count; } //////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the node has an outVariable (i.e. INTO ...) //////////////////////////////////////////////////////////////////////////////// inline bool hasOutVariable () const { return _outVariable != nullptr; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the out variable //////////////////////////////////////////////////////////////////////////////// Variable const* outVariable () const { return _outVariable; } //////////////////////////////////////////////////////////////////////////////// /// @brief clear the out variable //////////////////////////////////////////////////////////////////////////////// void clearOutVariable () { TRI_ASSERT(_outVariable != nullptr); _outVariable = nullptr; _count = false; } //////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the node has an expression variable (i.e. INTO ... /// = expr) //////////////////////////////////////////////////////////////////////////////// inline bool hasExpressionVariable () const { return _expressionVariable != nullptr; } //////////////////////////////////////////////////////////////////////////////// /// @brief set the expression variable //////////////////////////////////////////////////////////////////////////////// void setExpressionVariable (Variable const* variable) { TRI_ASSERT(! hasExpressionVariable()); _expressionVariable = variable; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the variable map //////////////////////////////////////////////////////////////////////////////// std::unordered_map const& variableMap () const { return _variableMap; } //////////////////////////////////////////////////////////////////////////////// /// @brief get all aggregate variables (out, in) //////////////////////////////////////////////////////////////////////////////// std::vector> const& aggregateVariables () const { return _aggregateVariables; } //////////////////////////////////////////////////////////////////////////////// /// @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 { std::vector v; size_t const n = _aggregateVariables.size() + (_outVariable == nullptr ? 0 : 1); v.reserve(n); for (auto const& p : _aggregateVariables) { v.emplace_back(p.first); } if (_outVariable != nullptr) { v.emplace_back(_outVariable); } return v; } // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief options for the aggregation //////////////////////////////////////////////////////////////////////////////// AggregationOptions _options; //////////////////////////////////////////////////////////////////////////////// /// @brief input/output variables for the aggregation (out, in) //////////////////////////////////////////////////////////////////////////////// std::vector> _aggregateVariables; //////////////////////////////////////////////////////////////////////////////// /// @brief input expression variable (might be null) //////////////////////////////////////////////////////////////////////////////// Variable const* _expressionVariable; //////////////////////////////////////////////////////////////////////////////// /// @brief output variable to write to (might be null) //////////////////////////////////////////////////////////////////////////////// Variable const* _outVariable; //////////////////////////////////////////////////////////////////////////////// /// @brief list of variables to keep if INTO is used //////////////////////////////////////////////////////////////////////////////// std::vector _keepVariables; //////////////////////////////////////////////////////////////////////////////// /// @brief map of all variable ids and names (needed to construct group data) //////////////////////////////////////////////////////////////////////////////// std::unordered_map const _variableMap; //////////////////////////////////////////////////////////////////////////////// /// @brief COUNTing node? //////////////////////////////////////////////////////////////////////////////// bool _count; //////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the node requires an additional post-SORT //////////////////////////////////////////////////////////////////////////////// bool const _isDistinctCommand; //////////////////////////////////////////////////////////////////////////////// /// @brief whether or not the node is specialized //////////////////////////////////////////////////////////////////////////////// bool _specialized; }; // ----------------------------------------------------------------------------- // --SECTION-- class ReturnNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @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*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return RETURN; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, 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); } // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief we need to know the offset and limit //////////////////////////////////////////////////////////////////////////////// Variable const* _inVariable; }; // ----------------------------------------------------------------------------- // --SECTION-- class ModificationNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief abstract base class for modification operations //////////////////////////////////////////////////////////////////////////////// class ModificationNode : public ExecutionNode { friend class ExecutionBlock; friend class ModificationBlock; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor with a vocbase and a collection and options //////////////////////////////////////////////////////////////////////////////// protected: ModificationNode (ExecutionPlan* plan, size_t id, TRI_vocbase_t* vocbase, Collection* collection, ModificationOptions const& options, Variable const* outVariableOld, Variable const* outVariableNew) : ExecutionNode(plan, id), _vocbase(vocbase), _collection(collection), _options(options), _outVariableOld(outVariableOld), _outVariableNew(outVariableNew) { TRI_ASSERT(_vocbase != nullptr); TRI_ASSERT(_collection != nullptr); } ModificationNode (ExecutionPlan*, triagens::basics::Json const& json); //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// virtual void toJsonHelper (triagens::basics::Json& json, TRI_memory_zone_t* zone, bool) const override; // ----------------------------------------------------------------------------- // --SECTION-- public methods // ----------------------------------------------------------------------------- public: //////////////////////////////////////////////////////////////////////////////// /// @brief return the database //////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* vocbase () const { return _vocbase; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the collection //////////////////////////////////////////////////////////////////////////////// Collection const* collection () const { return _collection; } //////////////////////////////////////////////////////////////////////////////// /// @brief estimateCost /// Note that all the modifying nodes use this estimateCost method which is /// why we can make it final here. //////////////////////////////////////////////////////////////////////////////// double estimateCost (size_t&) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief getOptions //////////////////////////////////////////////////////////////////////////////// ModificationOptions const& getOptions () const { return _options; } //////////////////////////////////////////////////////////////////////////////// /// @brief getOptions //////////////////////////////////////////////////////////////////////////////// ModificationOptions& getOptions () { return _options; } //////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesSetHere //////////////////////////////////////////////////////////////////////////////// std::vector getVariablesSetHere () const override final { std::vector v; if (_outVariableOld != nullptr) { v.emplace_back(_outVariableOld); } if (_outVariableNew != nullptr) { v.emplace_back(_outVariableNew); } return v; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the "$OLD" out variable //////////////////////////////////////////////////////////////////////////////// Variable const* getOutVariableOld () const { return _outVariableOld; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the "$NEW" out variable //////////////////////////////////////////////////////////////////////////////// Variable const* getOutVariableNew () const { return _outVariableNew; } //////////////////////////////////////////////////////////////////////////////// /// @brief clear the "$OLD" out variable //////////////////////////////////////////////////////////////////////////////// void clearOutVariableOld () { _outVariableOld = nullptr; } //////////////////////////////////////////////////////////////////////////////// /// @brief clear the "$NEW" out variable //////////////////////////////////////////////////////////////////////////////// void clearOutVariableNew () { _outVariableNew = nullptr; } // ----------------------------------------------------------------------------- // --SECTION-- protected variables // ----------------------------------------------------------------------------- protected: //////////////////////////////////////////////////////////////////////////////// /// @brief _vocbase, the database //////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* _vocbase; //////////////////////////////////////////////////////////////////////////////// /// @brief collection //////////////////////////////////////////////////////////////////////////////// Collection* _collection; //////////////////////////////////////////////////////////////////////////////// /// @brief modification operation options //////////////////////////////////////////////////////////////////////////////// ModificationOptions _options; //////////////////////////////////////////////////////////////////////////////// /// @brief output variable ($OLD) //////////////////////////////////////////////////////////////////////////////// Variable const* _outVariableOld; //////////////////////////////////////////////////////////////////////////////// /// @brief output variable ($NEW) //////////////////////////////////////////////////////////////////////////////// Variable const* _outVariableNew; }; // ----------------------------------------------------------------------------- // --SECTION-- class RemoveNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class RemoveNode //////////////////////////////////////////////////////////////////////////////// class RemoveNode : public ModificationNode { friend class ExecutionNode; friend class ExecutionBlock; friend class RemoveBlock; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor //////////////////////////////////////////////////////////////////////////////// public: RemoveNode (ExecutionPlan* plan, size_t id, TRI_vocbase_t* vocbase, Collection* collection, ModificationOptions const& options, Variable const* inVariable, Variable const* outVariableOld) : ModificationNode(plan, id, vocbase, collection, options, outVariableOld, nullptr), _inVariable(inVariable) { TRI_ASSERT(_inVariable != nullptr); } RemoveNode (ExecutionPlan*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return REMOVE; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, bool) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone (ExecutionPlan* plan, bool withDependencies, bool withProperties) 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); } // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief input variable //////////////////////////////////////////////////////////////////////////////// Variable const* _inVariable; }; // ----------------------------------------------------------------------------- // --SECTION-- class InsertNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class InsertNode //////////////////////////////////////////////////////////////////////////////// class InsertNode : public ModificationNode { friend class ExecutionNode; friend class ExecutionBlock; friend class InsertBlock; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor //////////////////////////////////////////////////////////////////////////////// public: InsertNode (ExecutionPlan* plan, size_t id, TRI_vocbase_t* vocbase, Collection* collection, ModificationOptions const& options, Variable const* inVariable, Variable const* outVariableNew) : ModificationNode(plan, id, vocbase, collection, options, nullptr, outVariableNew), _inVariable(inVariable) { TRI_ASSERT(_inVariable != nullptr); // _outVariable might be a nullptr } InsertNode (ExecutionPlan*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return INSERT; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, bool) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone (ExecutionPlan* plan, bool withDependencies, bool withProperties) 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); } // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief input variable //////////////////////////////////////////////////////////////////////////////// Variable const* _inVariable; }; // ----------------------------------------------------------------------------- // --SECTION-- class UpdateNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class UpdateNode //////////////////////////////////////////////////////////////////////////////// class UpdateNode : public ModificationNode { friend class ExecutionNode; friend class ExecutionBlock; friend class UpdateBlock; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor with a vocbase and a collection name //////////////////////////////////////////////////////////////////////////////// public: UpdateNode (ExecutionPlan* plan, size_t id, TRI_vocbase_t* vocbase, Collection* collection, ModificationOptions const& options, Variable const* inDocVariable, Variable const* inKeyVariable, Variable const* outVariableOld, Variable const* outVariableNew) : ModificationNode(plan, id, vocbase, collection, options, outVariableOld, outVariableNew), _inDocVariable(inDocVariable), _inKeyVariable(inKeyVariable) { TRI_ASSERT(_inDocVariable != nullptr); // _inKeyVariable might be a nullptr } UpdateNode (ExecutionPlan*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return UPDATE; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, bool) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone (ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, returning a vector //////////////////////////////////////////////////////////////////////////////// std::vector getVariablesUsedHere () const override final { // Please do not change the order here without adjusting the // optimizer rule distributeInCluster as well! std::vector v{ _inDocVariable }; if (_inKeyVariable != nullptr) { v.emplace_back(_inKeyVariable); } return v; } //////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, modifying the set in-place //////////////////////////////////////////////////////////////////////////////// void getVariablesUsedHere (std::unordered_set& vars) const override final { vars.emplace(_inDocVariable); if (_inKeyVariable != nullptr) { vars.emplace(_inKeyVariable); } } // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief input variable for documents //////////////////////////////////////////////////////////////////////////////// Variable const* _inDocVariable; //////////////////////////////////////////////////////////////////////////////// /// @brief input variable for keys //////////////////////////////////////////////////////////////////////////////// Variable const* _inKeyVariable; }; // ----------------------------------------------------------------------------- // --SECTION-- class ReplaceNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class ReplaceNode //////////////////////////////////////////////////////////////////////////////// class ReplaceNode : public ModificationNode { friend class ExecutionNode; friend class ExecutionBlock; friend class ReplaceBlock; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor with a vocbase and a collection name //////////////////////////////////////////////////////////////////////////////// public: ReplaceNode (ExecutionPlan* plan, size_t id, TRI_vocbase_t* vocbase, Collection* collection, ModificationOptions const& options, Variable const* inDocVariable, Variable const* inKeyVariable, Variable const* outVariableOld, Variable const* outVariableNew) : ModificationNode(plan, id, vocbase, collection, options, outVariableOld, outVariableNew), _inDocVariable(inDocVariable), _inKeyVariable(inKeyVariable) { TRI_ASSERT(_inDocVariable != nullptr); // _inKeyVariable might be a nullptr } ReplaceNode (ExecutionPlan*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return REPLACE; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, bool) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone (ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, returning a vector //////////////////////////////////////////////////////////////////////////////// std::vector getVariablesUsedHere () const override final { // Please do not change the order here without adjusting the // optimizer rule distributeInCluster as well! std::vector v{ _inDocVariable }; if (_inKeyVariable != nullptr) { v.emplace_back(_inKeyVariable); } return v; } //////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, modifying the set in-place //////////////////////////////////////////////////////////////////////////////// void getVariablesUsedHere (std::unordered_set& vars) const override final { vars.emplace(_inDocVariable); if (_inKeyVariable != nullptr) { vars.emplace(_inKeyVariable); } } // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief input variable for documents //////////////////////////////////////////////////////////////////////////////// Variable const* _inDocVariable; //////////////////////////////////////////////////////////////////////////////// /// @brief input variable for keys //////////////////////////////////////////////////////////////////////////////// Variable const* _inKeyVariable; }; // ----------------------------------------------------------------------------- // --SECTION-- class UpsertNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class UpsertNode //////////////////////////////////////////////////////////////////////////////// class UpsertNode : public ModificationNode { friend class ExecutionNode; friend class ExecutionBlock; friend class UpsertBlock; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor with a vocbase and a collection name //////////////////////////////////////////////////////////////////////////////// public: UpsertNode (ExecutionPlan* plan, size_t id, TRI_vocbase_t* vocbase, Collection* collection, ModificationOptions const& options, Variable const* inDocVariable, Variable const* insertVariable, Variable const* updateVariable, Variable const* outVariableNew, bool isReplace) : ModificationNode(plan, id, vocbase, collection, options, nullptr, outVariableNew), _inDocVariable(inDocVariable), _insertVariable(insertVariable), _updateVariable(updateVariable), _isReplace(isReplace) { TRI_ASSERT(_inDocVariable != nullptr); TRI_ASSERT(_insertVariable != nullptr); TRI_ASSERT(_updateVariable != nullptr); TRI_ASSERT(_outVariableOld == nullptr); } UpsertNode (ExecutionPlan*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return UPSERT; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, bool) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone (ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, returning a vector //////////////////////////////////////////////////////////////////////////////// std::vector getVariablesUsedHere () const override final { // Please do not change the order here without adjusting the // optimizer rule distributeInCluster as well! return std::vector({ _inDocVariable, _insertVariable, _updateVariable }); } //////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, modifying the set in-place //////////////////////////////////////////////////////////////////////////////// void getVariablesUsedHere (std::unordered_set& vars) const override final { vars.emplace(_inDocVariable); vars.emplace(_insertVariable); vars.emplace(_updateVariable); } // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- private: //////////////////////////////////////////////////////////////////////////////// /// @brief input variable for the search document //////////////////////////////////////////////////////////////////////////////// Variable const* _inDocVariable; //////////////////////////////////////////////////////////////////////////////// /// @brief insert case expression //////////////////////////////////////////////////////////////////////////////// Variable const* _insertVariable; //////////////////////////////////////////////////////////////////////////////// /// @brief update case expression //////////////////////////////////////////////////////////////////////////////// Variable const* _updateVariable; //////////////////////////////////////////////////////////////////////////////// /// @brief whether to perform a REPLACE (or an UPDATE alternatively) //////////////////////////////////////////////////////////////////////////////// bool const _isReplace; }; // ----------------------------------------------------------------------------- // --SECTION-- class NoResultsNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @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, triagens::basics::Json const& base) : ExecutionNode(plan, base) { } //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return NORESULTS; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, 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; }; // ----------------------------------------------------------------------------- // --SECTION-- class RemoteNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class RemoteNode //////////////////////////////////////////////////////////////////////////////// class RemoteNode : public ExecutionNode { friend class ExecutionBlock; friend class RemoteBlock; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor with an id //////////////////////////////////////////////////////////////////////////////// public: RemoteNode (ExecutionPlan* plan, size_t id, TRI_vocbase_t* vocbase, Collection const* collection, std::string const& server, std::string const& ownName, std::string const& queryId) : ExecutionNode(plan, id), _vocbase(vocbase), _collection(collection), _server(server), _ownName(ownName), _queryId(queryId) { // note: server, ownName and queryId may be empty and filled later } RemoteNode (ExecutionPlan*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return REMOTE; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, bool) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone (ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final { auto c = new RemoteNode(plan, _id, _vocbase, _collection, _server, _ownName, _queryId); cloneHelper(c, plan, withDependencies, withProperties); return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// /// @brief estimateCost //////////////////////////////////////////////////////////////////////////////// double estimateCost (size_t&) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief return the database //////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* vocbase () const { return _vocbase; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the collection //////////////////////////////////////////////////////////////////////////////// Collection const* collection () const { return _collection; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the server name //////////////////////////////////////////////////////////////////////////////// std::string server () const { return _server; } //////////////////////////////////////////////////////////////////////////////// /// @brief set the server name //////////////////////////////////////////////////////////////////////////////// void server (std::string const& server) { _server = server; } //////////////////////////////////////////////////////////////////////////////// /// @brief return our own name //////////////////////////////////////////////////////////////////////////////// std::string ownName () const { return _ownName; } //////////////////////////////////////////////////////////////////////////////// /// @brief set our own name //////////////////////////////////////////////////////////////////////////////// void ownName (std::string const& ownName) { _ownName = ownName; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the query id //////////////////////////////////////////////////////////////////////////////// std::string queryId () const { return _queryId; } //////////////////////////////////////////////////////////////////////////////// /// @brief set the query id //////////////////////////////////////////////////////////////////////////////// void queryId (std::string const& queryId) { _queryId = queryId; } //////////////////////////////////////////////////////////////////////////////// /// @brief set the query id //////////////////////////////////////////////////////////////////////////////// void queryId (QueryId queryId) { _queryId = triagens::basics::StringUtils::itoa(queryId); } private: //////////////////////////////////////////////////////////////////////////////// /// @brief the underlying database //////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* _vocbase; //////////////////////////////////////////////////////////////////////////////// /// @brief the underlying collection //////////////////////////////////////////////////////////////////////////////// Collection const* _collection; //////////////////////////////////////////////////////////////////////////////// /// @brief our server, can be like "shard:S1000" or like "server:Claus" //////////////////////////////////////////////////////////////////////////////// std::string _server; //////////////////////////////////////////////////////////////////////////////// /// @brief our own identity, in case of the coordinator this is empty, /// in case of the DBservers, this is the shard ID as a string //////////////////////////////////////////////////////////////////////////////// std::string _ownName; //////////////////////////////////////////////////////////////////////////////// /// @brief the ID of the query on the server as a string //////////////////////////////////////////////////////////////////////////////// std::string _queryId; }; // ----------------------------------------------------------------------------- // --SECTION-- class ScatterNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class ScatterNode //////////////////////////////////////////////////////////////////////////////// class ScatterNode : public ExecutionNode { friend class ExecutionBlock; friend class ScatterBlock; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor with an id //////////////////////////////////////////////////////////////////////////////// public: ScatterNode (ExecutionPlan* plan, size_t id, TRI_vocbase_t* vocbase, Collection const* collection) : ExecutionNode(plan, id), _vocbase(vocbase), _collection(collection) { } ScatterNode (ExecutionPlan*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return SCATTER; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, bool) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone (ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final { auto c = new ScatterNode(plan, _id, _vocbase, _collection); cloneHelper(c, plan, withDependencies, withProperties); return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// /// @brief estimateCost //////////////////////////////////////////////////////////////////////////////// double estimateCost (size_t&) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief return the database //////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* vocbase () const { return _vocbase; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the collection //////////////////////////////////////////////////////////////////////////////// Collection const* collection () const { return _collection; } private: //////////////////////////////////////////////////////////////////////////////// /// @brief the underlying database //////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* _vocbase; //////////////////////////////////////////////////////////////////////////////// /// @brief the underlying collection //////////////////////////////////////////////////////////////////////////////// Collection const* _collection; }; // ----------------------------------------------------------------------------- // --SECTION-- class DistributeNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class DistributeNode //////////////////////////////////////////////////////////////////////////////// class DistributeNode : public ExecutionNode { friend class ExecutionBlock; friend class DistributeBlock; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor with an id //////////////////////////////////////////////////////////////////////////////// public: DistributeNode (ExecutionPlan* plan, size_t id, TRI_vocbase_t* vocbase, Collection const* collection, VariableId const varId, VariableId const alternativeVarId, bool createKeys) : ExecutionNode(plan, id), _vocbase(vocbase), _collection(collection), _varId(varId), _alternativeVarId(alternativeVarId), _createKeys(createKeys) { } DistributeNode (ExecutionPlan* plan, size_t id, TRI_vocbase_t* vocbase, Collection const* collection, VariableId const varId, bool createKeys) : DistributeNode(plan, id, vocbase, collection, varId, varId, createKeys) { // just delegates to the other constructor } DistributeNode (ExecutionPlan*, triagens::basics::Json const& base); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return DISTRIBUTE; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, bool) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone (ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final { auto c = new DistributeNode(plan, _id, _vocbase, _collection, _varId, _alternativeVarId, _createKeys); cloneHelper(c, plan, withDependencies, withProperties); return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// /// @brief estimateCost //////////////////////////////////////////////////////////////////////////////// double estimateCost (size_t&) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief return the database //////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* vocbase () const { return _vocbase; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the collection //////////////////////////////////////////////////////////////////////////////// Collection const* collection () const { return _collection; } private: //////////////////////////////////////////////////////////////////////////////// /// @brief the underlying database //////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* _vocbase; //////////////////////////////////////////////////////////////////////////////// /// @brief the underlying collection //////////////////////////////////////////////////////////////////////////////// Collection const* _collection; //////////////////////////////////////////////////////////////////////////////// /// @brief the variable we must inspect to know where to distribute //////////////////////////////////////////////////////////////////////////////// VariableId const _varId; //////////////////////////////////////////////////////////////////////////////// /// @brief an optional second variable we must inspect to know where to /// distribute //////////////////////////////////////////////////////////////////////////////// VariableId const _alternativeVarId; //////////////////////////////////////////////////////////////////////////////// /// @brief the node is responsible for creating document keys //////////////////////////////////////////////////////////////////////////////// bool const _createKeys; }; // ----------------------------------------------------------------------------- // --SECTION-- class GatherNode // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief class GatherNode //////////////////////////////////////////////////////////////////////////////// class GatherNode : public ExecutionNode { friend class ExecutionBlock; friend class GatherBlock; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor with an id //////////////////////////////////////////////////////////////////////////////// public: GatherNode (ExecutionPlan* plan, size_t id, TRI_vocbase_t* vocbase, Collection const* collection) : ExecutionNode(plan, id), _vocbase(vocbase), _collection(collection) { } GatherNode (ExecutionPlan*, triagens::basics::Json const& base, SortElementVector const& elements); //////////////////////////////////////////////////////////////////////////////// /// @brief return the type of the node //////////////////////////////////////////////////////////////////////////////// NodeType getType () const override final { return GATHER; } //////////////////////////////////////////////////////////////////////////////// /// @brief export to JSON //////////////////////////////////////////////////////////////////////////////// void toJsonHelper (triagens::basics::Json&, TRI_memory_zone_t*, bool) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief clone ExecutionNode recursively //////////////////////////////////////////////////////////////////////////////// ExecutionNode* clone (ExecutionPlan* plan, bool withDependencies, bool withProperties) const override final { auto c = new GatherNode(plan, _id, _vocbase, _collection); cloneHelper(c, plan, withDependencies, withProperties); return static_cast(c); } //////////////////////////////////////////////////////////////////////////////// /// @brief estimateCost //////////////////////////////////////////////////////////////////////////////// double estimateCost (size_t&) const override final; //////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, returning a vector //////////////////////////////////////////////////////////////////////////////// std::vector getVariablesUsedHere () const override final { std::vector v; v.reserve(_elements.size()); for (auto const& p : _elements) { v.emplace_back(p.first); } return v; } //////////////////////////////////////////////////////////////////////////////// /// @brief getVariablesUsedHere, modifying the set in-place //////////////////////////////////////////////////////////////////////////////// void getVariablesUsedHere (std::unordered_set& vars) const override final { for (auto const& p : _elements) { vars.emplace(p.first); } } //////////////////////////////////////////////////////////////////////////////// /// @brief get Variables Used Here including ASC/DESC //////////////////////////////////////////////////////////////////////////////// SortElementVector const & getElements () const { return _elements; } void setElements (SortElementVector const & src) { _elements = src; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the database //////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* vocbase () const { return _vocbase; } //////////////////////////////////////////////////////////////////////////////// /// @brief return the collection //////////////////////////////////////////////////////////////////////////////// Collection const* collection () const { return _collection; } private: //////////////////////////////////////////////////////////////////////////////// /// @brief pairs, consisting of variable and sort direction /// (true = ascending | false = descending) //////////////////////////////////////////////////////////////////////////////// SortElementVector _elements; //////////////////////////////////////////////////////////////////////////////// /// @brief the underlying database //////////////////////////////////////////////////////////////////////////////// TRI_vocbase_t* _vocbase; //////////////////////////////////////////////////////////////////////////////// /// @brief the underlying collection //////////////////////////////////////////////////////////////////////////////// Collection const* _collection; }; } // namespace triagens::aql } // namespace triagens #endif // Local Variables: // mode: outline-minor // outline-regexp: "^\\(/// @brief\\|/// {@inheritDoc}\\|/// @addtogroup\\|// --SECTION--\\|/// @\\}\\)" // End: