mirror of https://gitee.com/bigwinds/arangodb
399 lines
15 KiB
C++
399 lines
15 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief infrastructure for query optimizer
|
|
///
|
|
/// @file arangod/Aql/Optimizer.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 ARANGOD_AQL_OPTIMIZER_H
|
|
#define ARANGOD_AQL_OPTIMIZER_H 1
|
|
|
|
#include <Basics/Common.h>
|
|
|
|
#include "Aql/ExecutionPlan.h"
|
|
|
|
namespace triagens {
|
|
namespace aql {
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- the optimizer class
|
|
// -----------------------------------------------------------------------------
|
|
|
|
class Optimizer {
|
|
|
|
public:
|
|
|
|
struct Rule;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief type of an optimizer rule function, the function gets an
|
|
/// optimiser, an ExecutionPlan, and the current rule. it has
|
|
/// to append one or more plans to the resulting deque. This must
|
|
/// include the original plan if it ought to be kept. The rule has to
|
|
/// set the level of the appended plan to the largest level of rule
|
|
/// that ought to be considered as done to indicate which rule is to be
|
|
/// applied next.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef std::function<int(Optimizer*, ExecutionPlan*, Rule const*)> RuleFunction;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief type of an optimizer rule
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
struct Rule {
|
|
std::string name;
|
|
RuleFunction func;
|
|
int level;
|
|
|
|
Rule () = delete;
|
|
|
|
Rule (std::string const& name, RuleFunction func, int level)
|
|
: name(name),
|
|
func(func),
|
|
level(level) {
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief the following struct keeps a list (deque) of ExecutionPlan*
|
|
/// and has some automatic convenience functions.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
struct PlanList {
|
|
std::deque<ExecutionPlan*> list;
|
|
std::deque<int> levelDone;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief constructor
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
PlanList () {};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief constructor with a plan
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
PlanList (ExecutionPlan* p, int level) {
|
|
push_back(p, level);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destructor, deleting contents
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
~PlanList () {
|
|
for (auto p : list) {
|
|
delete p;
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get number of plans contained
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
size_t size () const {
|
|
return list.size();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief check if empty
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool empty () const {
|
|
return list.empty();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief pop the first one
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
ExecutionPlan* pop_front (int& levelDoneOut) {
|
|
auto p = list.front();
|
|
levelDoneOut = levelDone.front();
|
|
list.pop_front();
|
|
levelDone.pop_front();
|
|
return p;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief push_back
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void push_back (ExecutionPlan* p, int level) {
|
|
list.push_back(p);
|
|
try {
|
|
levelDone.push_back(level);
|
|
}
|
|
catch (...) {
|
|
list.pop_back();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief steals all the plans in b and clears b at the same time
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void steal (PlanList& b) {
|
|
list.swap(b.list);
|
|
levelDone.swap(b.levelDone);
|
|
for (auto p : b.list) {
|
|
delete p;
|
|
}
|
|
b.list.clear();
|
|
b.levelDone.clear();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief appends all the plans to the target and clears *this at the same time
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void appendTo (PlanList& target) {
|
|
while (list.size() > 0) {
|
|
auto p = list.front();
|
|
int level = levelDone.front();
|
|
list.pop_front();
|
|
levelDone.pop_front();
|
|
try {
|
|
target.push_back(p, level);
|
|
}
|
|
catch (...) {
|
|
delete p;
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief clear, deletes all plans contained
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void clear () {
|
|
for (auto p : list) {
|
|
delete p;
|
|
}
|
|
list.clear();
|
|
levelDone.clear();
|
|
}
|
|
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief maximal number of plans to produce:
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static int const maxNumberOfPlans = 1000;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief constructor, this will initialize the rules database
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Optimizer (); // the .cpp file includes Aql/OptimizerRules.h
|
|
// and add all methods there to the rules database
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destructor
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
~Optimizer () {
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief do the optimization, this does the optimization, the resulting
|
|
/// plans are all estimated, sorted by that estimate and can then be got
|
|
/// by getPlans, until the next initialize is called. Note that the optimizer
|
|
/// object takes ownership of the execution plan and will delete it
|
|
/// automatically on destruction. It will also have ownership of all the
|
|
/// newly created plans it recalls and will automatically delete them.
|
|
/// If you need to extract the plans from the optimizer use stealBest or
|
|
/// stealPlans.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int createPlans (ExecutionPlan* p,
|
|
std::vector<std::string> const&);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief add a plan to the optimizer
|
|
/// returns false if there are already enough plans, true otherwise
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool addPlan (ExecutionPlan*,
|
|
int,
|
|
bool);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief getBest, ownership of the plan remains with the optimizer
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
ExecutionPlan* getBest () {
|
|
if (_plans.empty()) {
|
|
return nullptr;
|
|
}
|
|
return _plans.list.front();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief getPlans, ownership of the plans remains with the optimizer
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
std::deque<ExecutionPlan*>& getPlans () {
|
|
return _plans.list;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief stealBest, ownership of the plan is handed over to the caller,
|
|
/// all other plans are deleted
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
ExecutionPlan* stealBest () {
|
|
if (_plans.empty()) {
|
|
return nullptr;
|
|
}
|
|
auto res = _plans.list.front();
|
|
for (size_t i = 1; i < _plans.size(); i++) {
|
|
delete _plans.list[i];
|
|
}
|
|
_plans.list.clear();
|
|
_plans.levelDone.clear();
|
|
|
|
return res;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief stealPlans, ownership of the plans is handed over to the caller,
|
|
/// the optimizer will forget about them!
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
std::deque<ExecutionPlan*> stealPlans () {
|
|
std::deque<ExecutionPlan*> res;
|
|
res.swap(_plans.list);
|
|
_plans.levelDone.clear();
|
|
return res;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief translate a list of rule ids into rule name
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static std::vector<std::string> translateRules (std::vector<int> const&);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- private methods
|
|
// -----------------------------------------------------------------------------
|
|
|
|
private:
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief estimatePlans
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void estimatePlans ();
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief sortPlans
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void sortPlans ();
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief look up the ids of all disabled rules
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
std::unordered_set<int> getDisabledRuleIds (std::vector<std::string> const&) const;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief registerRule
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static void registerRule (std::string const& name,
|
|
RuleFunction func,
|
|
int level) {
|
|
if (_ruleLookup.find(name) != _ruleLookup.end()) {
|
|
// duplicate rule names are not allowed
|
|
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL, "duplicate optimizer rule name");
|
|
}
|
|
|
|
_ruleLookup.insert(std::make_pair(name, level));
|
|
|
|
if (_rules.find(level) != _rules.end()) {
|
|
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL, "duplicate optimizer rule level");
|
|
}
|
|
|
|
_rules.insert(std::make_pair(level, Rule(name, func, level)));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up the optimizer rules once and forever
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static void setupRules ();
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- private members
|
|
// -----------------------------------------------------------------------------
|
|
|
|
private:
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief the rules database
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static std::map<int, Rule> _rules;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief map to look up rule id by name
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static std::unordered_map<std::string, int> _ruleLookup;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief the current set of plans to be optimised
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
PlanList _plans;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief current list of plans (while applying optimizer rules)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
PlanList _newPlans;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief currently active rule (during optimization)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int _currentRule;
|
|
|
|
};
|
|
|
|
} // namespace aql
|
|
} // namespace triagens
|
|
#endif
|
|
|
|
// Local Variables:
|
|
// mode: outline-minor
|
|
// outline-regexp: "^\\(/// @brief\\|/// {@inheritDoc}\\|/// @addtogroup\\|// --SECTION--\\|/// @\\}\\)"
|
|
// End:
|
|
|