#include <RelAlgDag.h>

Inheritance diagram for RelAlgDagBuilder:

Collaboration diagram for RelAlgDagBuilder:

Static Public Member Functions
static std::unique_ptr< RelAlgDag >	buildDag (const std::string &query_ra, const bool optimize_dag)

static std::unique_ptr< RelAlgDag >	buildDagForSubquery (RelAlgDag &root_dag, const rapidjson::Value &query_ast)

static void	optimizeDag (RelAlgDag &rel_alg_dag)

Static Private Member Functions
static std::unique_ptr< RelAlgDag >	build (const rapidjson::Value &query_ast, RelAlgDag *root_dag, const bool optimize_dag)

Additional Inherited Members
Static Protected Member Functions inherited from RelAlgDagModifier
static std::vector < std::shared_ptr< RelAlgNode > > &	getNodes (RelAlgDag &rel_alg_dag)

static std::vector < std::shared_ptr< RexSubQuery > > &	getSubqueries (RelAlgDag &rel_alg_dag)

static std::unordered_map < size_t, std::unordered_map < unsigned, RegisteredQueryHint > > &	getQueryHints (RelAlgDag &rel_alg_dag)

static void	setBuildState (RelAlgDag &rel_alg_dag, const RelAlgDag::BuildState build_state)

Detailed Description

Builder struct to create a RelAlgDag instance. Can optionally apply high level optimizations which can be expressed through relational algebra extended with RelCompound. The RelCompound node is an equivalent representation for sequences of RelFilter, RelProject and RelAggregate nodes. This coalescing minimizes the amount of intermediate buffers required to evaluate a query. Lower level optimizations are taken care by lower levels, mainly RelAlgTranslator and the IR code generation.

Definition at line 3432 of file RelAlgDag.h.

Member Function Documentation

std::unique_ptr< RelAlgDag > RelAlgDagBuilder::build	(	const rapidjson::Value &	query_ast,
		RelAlgDag *	root_dag,
		const bool	optimize_dag
	)

staticprivate

Definition at line 3384 of file RelAlgDag.cpp.

References anonymous_namespace{RelAlgDag.cpp}::bind_inputs(), CHECK, field(), RelAlgDagModifier::getNodes(), RelAlgDag::kBuiltNotOptimized, optimizeDag(), details::RelAlgDispatcher::run(), and RelAlgDagModifier::setBuildState().

Referenced by buildDag(), and buildDagForSubquery().

                                                                             {
   const auto& rels = field(query_ast, "rels");
   CHECK(rels.IsArray());
 
   auto rel_alg_dag_ptr = std::make_unique<RelAlgDag>();
   auto& rel_alg_dag = *rel_alg_dag_ptr;
   auto& nodes = getNodes(rel_alg_dag);
 
   try {
     nodes = details::RelAlgDispatcher().run(rels, root_dag ? *root_dag : rel_alg_dag);
   } catch (const QueryNotSupported&) {
     throw;
   }
   CHECK(!nodes.empty());
   bind_inputs(nodes);
 
   setBuildState(rel_alg_dag, RelAlgDag::BuildState::kBuiltNotOptimized);
 
   if (optimize_dag) {
     optimizeDag(rel_alg_dag);
   }
 
   return rel_alg_dag_ptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr< RelAlgDag > RelAlgDagBuilder::buildDag	(	const std::string &	query_ra,
		const bool	optimize_dag
	)

static

Constructs a RelAlg DAG from a relative-algebra JSON representation.

Parameters

query_ra	A JSON string representation of an RA tree from Calcite.
cat	DB catalog for the current user.

Definition at line 3358 of file RelAlgDag.cpp.

References build(), CHECK, logger::ERROR, LOG, RelAlgNode::resetRelAlgFirstId(), and VLOG.

                                                                                {
   rapidjson::Document query_ast;
   query_ast.Parse(query_ra.c_str());
   VLOG(2) << "Parsing query RA JSON: " << query_ra;
   if (query_ast.HasParseError()) {
     query_ast.GetParseError();
     LOG(ERROR) << "Failed to parse RA tree from Calcite (offset "
                << query_ast.GetErrorOffset() << "):\n"
                << rapidjson::GetParseError_En(query_ast.GetParseError());
     VLOG(1) << "Failed to parse query RA: " << query_ra;
     throw std::runtime_error(
         "Failed to parse relational algebra tree. Possible query syntax error.");
   }
   CHECK(query_ast.IsObject());
   RelAlgNode::resetRelAlgFirstId();
 
   return build(query_ast, nullptr, optimize_dag);
 }

Here is the call graph for this function:

std::unique_ptr< RelAlgDag > RelAlgDagBuilder::buildDagForSubquery	(	RelAlgDag &	root_dag,
		const rapidjson::Value &	query_ast
	)

static

Constructs a rel-alg DAG for any subqueries. Should only be called during DAG building.

Parameters

root_dag	The root DAG builder. The root stores pointers to all subqueries.
query_ast	The current JSON node to build a DAG for.
cat	DB catalog for the current user.

Definition at line 3378 of file RelAlgDag.cpp.

References build().

Referenced by anonymous_namespace{RelAlgDag.cpp}::parse_subquery().

                                      {
   return build(query_ast, &root_dag, true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void RelAlgDagBuilder::optimizeDag ( RelAlgDag & rel_alg_dag )

static

Definition at line 3411 of file RelAlgDag.cpp.

Referenced by build().

                                                          {
   auto const build_state = rel_alg_dag.getBuildState();
   if (build_state == RelAlgDag::BuildState::kBuiltOptimized) {
     return;
   }
 
   CHECK(build_state == RelAlgDag::BuildState::kBuiltNotOptimized)
       << static_cast<int>(build_state);
 
   auto& nodes = getNodes(rel_alg_dag);
   auto& subqueries = getSubqueries(rel_alg_dag);
   auto& query_hints = getQueryHints(rel_alg_dag);
 
   compute_node_hash(nodes);
   handle_query_hint(nodes, rel_alg_dag);
   mark_nops(nodes);
   simplify_sort(nodes);
   sink_projected_boolean_expr_to_join(nodes);
   eliminate_identical_copy(nodes);
   fold_filters(nodes);
   std::vector<const RelAlgNode*> filtered_left_deep_joins;
   std::vector<const RelAlgNode*> left_deep_joins;
   for (const auto& node : nodes) {
     const auto left_deep_join_root = get_left_deep_join_root(node);
     // The filter which starts a left-deep join pattern must not be coalesced
     // since it contains (part of) the join condition.
     if (left_deep_join_root) {
       left_deep_joins.push_back(left_deep_join_root.get());
       if (std::dynamic_pointer_cast<const RelFilter>(left_deep_join_root)) {
         filtered_left_deep_joins.push_back(left_deep_join_root.get());
       }
     }
   }
   if (filtered_left_deep_joins.empty()) {
     hoist_filter_cond_to_cross_join(nodes);
   }
   eliminate_dead_columns(nodes);
   eliminate_dead_subqueries(subqueries, nodes.back().get());
   separate_window_function_expressions(nodes, query_hints);
   add_window_function_pre_project(
       nodes,
       g_cluster /* always_add_project_if_first_project_is_window_expr */,
       query_hints);
   coalesce_nodes(nodes, left_deep_joins, query_hints);
   CHECK(nodes.back().use_count() == 1);
   create_left_deep_join(nodes);
   handle_agg_over_join(nodes, query_hints);
   eliminate_redundant_projection(nodes);
 
   setBuildState(rel_alg_dag, RelAlgDag::BuildState::kBuiltOptimized);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

The documentation for this struct was generated from the following files:

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/RelAlgDag.h
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/RelAlgDag.cpp

Static Public Member Functions

Static Private Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation