Optimizer.hpp

Go to the documentation of this file.

#pragma once
 
#include <mutable/mutable-config.hpp>
#include <mutable/catalog/CostFunction.hpp>
#include <mutable/IR/PlanEnumerator.hpp>
#include <mutable/IR/PlanTable.hpp>
 
 
namespace m {
 
struct M_EXPORT Optimizer
{
    using Subproblem = QueryGraph::Subproblem;
    using projection_type = QueryGraph::projection_type;
    using order_type = QueryGraph::order_type;
 
    private:
    const pe::PlanEnumerator &pe_;
    const CostFunction &cf_;
    mutable std::vector<std::unique_ptr<const ast::Expr>> created_exprs_; 
    mutable bool needs_projection_ = false; 
 
    public:
    Optimizer(const pe::PlanEnumerator &pe, const CostFunction &cf) : pe_(pe), cf_(cf) { }
 
    auto & plan_enumerator() const { return pe_; }
    auto & cost_function() const { return cf_; }
 
    std::unique_ptr<Producer> operator()(QueryGraph &G) const { return optimize(G).first; }
 
    std::pair<std::unique_ptr<Producer>, PlanTableEntry> optimize(QueryGraph &G) const;
 
    template<typename PlanTable>
    std::pair<std::unique_ptr<Producer>, PlanTable> optimize_with_plantable(QueryGraph &G) const;
 
    private:
    template<typename PlanTable>
    std::unique_ptr<Producer*[]> optimize_source_plans(const QueryGraph &G, PlanTable &PT) const;
 
    template<typename PlanTable>
    void optimize_join_order(const QueryGraph &G, PlanTable &PT) const;
 
    template<typename PlanTable>
    std::unique_ptr<Producer> construct_join_order(const QueryGraph &G, const PlanTable &PT,
                                                   const std::unique_ptr<Producer*[]> &source_plans) const;
 
    std::unique_ptr<Producer> optimize_plan(const QueryGraph &G, std::unique_ptr<Producer> plan,
                                            PlanTableEntry &entry) const;
 
    static std::vector<cnf::CNF> optimize_filter(cnf::CNF filter);
 
    static std::vector<projection_type>
    compute_projections_required_for_order_by(const std::vector<projection_type> &projections,
                                              const std::vector<order_type> &order_by);
};
 
}