The optimizer interface. More...

#include <Optimizer.hpp>

Collaboration diagram for m::Optimizer:

Public Types
using	Subproblem = QueryGraph::Subproblem

using	projection_type = QueryGraph::projection_type

using	order_type = QueryGraph::order_type

Public Member Functions
	Optimizer (const pe::PlanEnumerator &pe, const CostFunction &cf)

auto &	plan_enumerator () const

auto &	cost_function () const

std::unique_ptr< Producer >	operator() (QueryGraph &G) const
	Applies this optimizer to the given query graph `G` to compute an optimal logical operator tree.

std::pair< std::unique_ptr< Producer >, PlanTableEntry >	optimize (QueryGraph &G) const
	Computes and constructs an optimal logical plan for the given query graph `G`.

template<typename PlanTable >
std::pair< std::unique_ptr< Producer >, PlanTable >	optimize_with_plantable (QueryGraph &G) const
	Recursively computes and constructs an optimal logical plan for the given query graph `G`, using the given.

Private Member Functions
template<typename PlanTable >
std::unique_ptr< Producer *[]>	optimize_source_plans (const QueryGraph &G, PlanTable &PT) const
	Initializes the plan table `PT` with the data source entries contained in `G`.

template<typename PlanTable >
void	optimize_join_order (const QueryGraph &G, PlanTable &PT) const
	Optimizes the join order using the plan table `PT` which already contains entries for all data sources of the query graph `G`.

template<typename PlanTable >
std::unique_ptr< Producer >	construct_join_order (const QueryGraph &G, const PlanTable &PT, const std::unique_ptr< Producer *[]> &source_plans) const
	Constructs a join operator tree given a solved plan table `PT` and the plans to compute the data sources `source_plans` of the query graph `G`.

std::unique_ptr< Producer >	optimize_plan (const QueryGraph &G, std::unique_ptr< Producer > plan, PlanTableEntry &entry) const
	Optimizes and constructs an operator tree given a join operator tree `plan` and the final plan table entry `entry` for the query graph `G`.

Static Private Member Functions
static std::vector< cnf::CNF >	optimize_filter (cnf::CNF filter)
	Optimizes the filter `filter` by splitting it into smaller filters and ordering them.

static std::vector< projection_type >	compute_projections_required_for_order_by (const std::vector< projection_type > &projections, const std::vector< order_type > &order_by)
	Computes and returns a `std::vector` of additional projections required before evaluating the ORDER BY clause.

Private Attributes
const pe::PlanEnumerator &	pe_

const CostFunction &	cf_

std::vector< std::unique_ptr< const ast::Expr > >	created_exprs_
	additionally created expressions

bool	needs_projection_ = false
	flag to determine whether current query needs a projection as root

Detailed Description

The optimizer interface.

The Optimizer applies a join ordering algorithm to a query graph to compute a join order that minimizes the costs under a given logical cost function. Additionally, the optimizer may apply several semantics preserving transformations to improve performance. Such transformations include query unnesting and predicate inference.

Definition at line 18 of file Optimizer.hpp.

Member Typedef Documentation

◆ order_type

using m::Optimizer::order_type = QueryGraph::order_type

Definition at line 22 of file Optimizer.hpp.

◆ projection_type

using m::Optimizer::projection_type = QueryGraph::projection_type

Definition at line 21 of file Optimizer.hpp.

◆ Subproblem

using m::Optimizer::Subproblem = QueryGraph::Subproblem

Definition at line 20 of file Optimizer.hpp.

Constructor & Destructor Documentation

◆ Optimizer()

m::Optimizer::Optimizer	(	const pe::PlanEnumerator &	pe,
		const CostFunction &	cf
	)

inline

Definition at line 31 of file Optimizer.hpp.

Member Function Documentation

◆ compute_projections_required_for_order_by()

std::vector< Optimizer::projection_type > Optimizer::compute_projections_required_for_order_by	(	const std::vector< projection_type > &	projections,
		const std::vector< order_type > &	order_by
	)

staticprivate

Computes and returns a std::vector of additional projections required before evaluating the ORDER BY clause.

The returned std::vector may be empty, in which case no additional projection is required.

Definition at line 110 of file Optimizer.cpp.

References m::and, and m::visit().

Referenced by optimize_plan().

◆ construct_join_order()

template<typename PlanTable >

std::unique_ptr< Producer > Optimizer::construct_join_order	(	const QueryGraph &	G,
		const PlanTable &	PT,
		const std::unique_ptr< Producer *[]> &	source_plans
	)		const