Namespaces
	anonymous_namespace{RelAlgDagBuilder.cpp}

Classes
class	RexRebindInputsVisitor

class	RexRebindReindexInputsVisitor

class	RANodeIterator

class	WindowFunctionDetectionVisitor

class	RexWindowFuncReplacementVisitor

class	RexInputBackpropagationVisitor

class	RexInputCollector

Typedefs
using	RexInputSet = std::unordered_set< RexInput >

Functions
std::vector< RexInput >	n_outputs (const RelAlgNode *node, const size_t n)

bool	isRenamedInput (const RelAlgNode *node, const size_t index, const std::string &new_name)

std::vector< std::unique_ptr < const RexAgg > >	copyAggExprs (std::vector< std::unique_ptr< const RexAgg >> const &agg_exprs)

std::vector< std::unique_ptr < const RexScalar > >	copyRexScalars (std::vector< std::unique_ptr< const RexScalar >> const &scalar_sources)

std::vector< const Rex * >	remapTargetPointers (std::vector< std::unique_ptr< const RexAgg >> const &agg_exprs_new, std::vector< std::unique_ptr< const RexScalar >> const &scalar_sources_new, std::vector< std::unique_ptr< const RexAgg >> const &agg_exprs_old, std::vector< std::unique_ptr< const RexScalar >> const &scalar_sources_old, std::vector< const Rex * > const &target_exprs_old)

std::set< std::pair< const RelAlgNode *, int > >	get_equiv_cols (const RelAlgNode *node, const size_t which_col)

unsigned	node_id (const rapidjson::Value &ra_node) noexcept

std::string	json_node_to_string (const rapidjson::Value &node) noexcept

std::unique_ptr< RexAbstractInput >	parse_abstract_input (const rapidjson::Value &expr) noexcept

std::unique_ptr< RexLiteral >	parse_literal (const rapidjson::Value &expr)

std::unique_ptr< const RexScalar >	parse_scalar_expr (const rapidjson::Value &expr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)

SQLTypeInfo	parse_type (const rapidjson::Value &type_obj)

std::vector< std::unique_ptr < const RexScalar > >	parse_expr_array (const rapidjson::Value &arr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)

SqlWindowFunctionKind	parse_window_function_kind (const std::string &name)

std::vector< std::unique_ptr < const RexScalar > >	parse_window_order_exprs (const rapidjson::Value &arr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)

SortDirection	parse_sort_direction (const rapidjson::Value &collation)

NullSortedPosition	parse_nulls_position (const rapidjson::Value &collation)

std::vector< SortField >	parse_window_order_collation (const rapidjson::Value &arr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)

RexWindowFunctionOperator::RexWindowBound	parse_window_bound (const rapidjson::Value &window_bound_obj, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)

std::unique_ptr< const RexSubQuery >	parse_subquery (const rapidjson::Value &expr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)

std::unique_ptr< RexOperator >	parse_operator (const rapidjson::Value &expr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)

std::unique_ptr< RexCase >	parse_case (const rapidjson::Value &expr, const Catalog_Namespace::Catalog &cat, RelAlgDagBuilder &root_dag_builder)

std::vector< std::string >	strings_from_json_array (const rapidjson::Value &json_str_arr) noexcept

std::vector< size_t >	indices_from_json_array (const rapidjson::Value &json_idx_arr) noexcept

std::unique_ptr< const RexAgg >	parse_aggregate_expr (const rapidjson::Value &expr)

JoinType	to_join_type (const std::string &join_type_name)

std::unique_ptr< const RexScalar >	disambiguate_rex (const RexScalar *, const RANodeOutput &)

std::unique_ptr< const RexOperator >	disambiguate_operator (const RexOperator *rex_operator, const RANodeOutput &ra_output) noexcept

std::unique_ptr< const RexCase >	disambiguate_case (const RexCase *rex_case, const RANodeOutput &ra_output)

void	bind_project_to_input (RelProject *project_node, const RANodeOutput &input) noexcept

void	bind_table_func_to_input (RelTableFunction *table_func_node, const RANodeOutput &input) noexcept

void	bind_inputs (const std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept

void	handleQueryHint (const std::vector< std::shared_ptr< RelAlgNode >> &nodes, RelAlgDagBuilder *dag_builder) noexcept

void	mark_nops (const std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept

void	create_compound (std::vector< std::shared_ptr< RelAlgNode >> &nodes, const std::vector< size_t > &pattern, std::unordered_map< size_t, RegisteredQueryHint > &query_hints) noexcept

void	coalesce_nodes (std::vector< std::shared_ptr< RelAlgNode >> &nodes, const std::vector< const RelAlgNode * > &left_deep_joins, std::unordered_map< size_t, RegisteredQueryHint > &query_hints)

void	propagate_hints_to_new_project (std::shared_ptr< RelProject > prev_node, std::shared_ptr< RelProject > new_node, std::unordered_map< size_t, RegisteredQueryHint > &query_hints)

void	separate_window_function_expressions (std::vector< std::shared_ptr< RelAlgNode >> &nodes, std::unordered_map< size_t, RegisteredQueryHint > &query_hints)

void	add_window_function_pre_project (std::vector< std::shared_ptr< RelAlgNode >> &nodes, const bool always_add_project_if_first_project_is_window_expr, std::unordered_map< size_t, RegisteredQueryHint > &query_hints)

int64_t	get_int_literal_field (const rapidjson::Value &obj, const char field[], const int64_t default_val) noexcept

void	check_empty_inputs_field (const rapidjson::Value &node) noexcept

const TableDescriptor *	getTableFromScanNode (const Catalog_Namespace::Catalog &cat, const rapidjson::Value &scan_ra)

std::vector< std::string >	getFieldNamesFromScanNode (const rapidjson::Value &scan_ra)

Variables
const unsigned	FIRST_RA_NODE_ID = 1

Typedef Documentation

using anonymous_namespace{RelAlgDagBuilder.cpp}::RexInputSet = typedef std::unordered_set<RexInput>

Definition at line 2068 of file RelAlgDagBuilder.cpp.

Function Documentation

void anonymous_namespace{RelAlgDagBuilder.cpp}::add_window_function_pre_project	(	std::vector< std::shared_ptr< RelAlgNode >> &	nodes,
		const bool	always_add_project_if_first_project_is_window_expr,
		std::unordered_map< size_t, RegisteredQueryHint > &	query_hints
	)

Inserts a simple project before any project containing a window function node. Forces all window function inputs into a single contiguous buffer for centralized processing (e.g. in distributed mode). This is also needed when a window function node is preceded by a filter node, both for correctness (otherwise a window operator will be coalesced with its preceding filter node and be computer over unfiltered results, and for performance, as currently filter nodes that are not coalesced into projects keep all columns from the table as inputs, and hence bring everything in memory. Once the new project has been created, the inputs in the window function project must be rewritten to read from the new project, and to index off the projected exprs in the new project.

Definition at line 2097 of file RelAlgDagBuilder.cpp.

References anonymous_namespace{Utm.h}::a, CHECK, CHECK_EQ, i, propagate_hints_to_new_project(), gpu_enabled::sort(), and RexVisitorBase< T >::visit().

Referenced by RelAlgDagBuilder::build().

                                                                 {
   std::list<std::shared_ptr<RelAlgNode>> node_list(nodes.begin(), nodes.end());
   size_t project_node_counter{0};
   for (auto node_itr = node_list.begin(); node_itr != node_list.end(); ++node_itr) {
     const auto node = *node_itr;
 
     auto window_func_project_node = std::dynamic_pointer_cast<RelProject>(node);
     if (!window_func_project_node) {
       continue;
     }
     project_node_counter++;
     if (!window_func_project_node->hasWindowFunctionExpr()) {
       // this projection node does not have a window function
       // expression -- skip to the next node in the DAG.
       continue;
     }
 
     const auto prev_node_itr = std::prev(node_itr);
     const auto prev_node = *prev_node_itr;
     CHECK(prev_node);
 
     auto filter_node = std::dynamic_pointer_cast<RelFilter>(prev_node);
 
     auto scan_node = std::dynamic_pointer_cast<RelScan>(prev_node);
     const bool has_multi_fragment_scan_input =
         (scan_node && (scan_node->getNumShards() > 0 || scan_node->getNumFragments() > 1))
             ? true
             : false;
 
     // We currently add a preceding project node in one of two conditions:
     // 1. always_add_project_if_first_project_is_window_expr = true, which
     // we currently only set for distributed, but could also be set to support
     // multi-frag window function inputs, either if we can detect that an input table
     // is multi-frag up front, or using a retry mechanism like we do for join filter
     // push down.
     // TODO(todd): Investigate a viable approach for the above.
     // 2. Regardless of #1, if the window function project node is preceded by a
     // filter node. This is required both for correctness and to avoid pulling
     // all source input columns into memory since non-coalesced filter node
     // inputs are currently not pruned or eliminated via dead column elimination.
     // Note that we expect any filter node followed by a project node to be coalesced
     // into a single compound node in RelAlgDagBuilder::coalesce_nodes, and that action
     // prunes unused inputs.
     // TODO(todd): Investigate whether the shotgun filter node issue affects other
     // query plans, i.e. filters before joins, and whether there is a more general
     // approach to solving this (will still need the preceding project node for
     // window functions preceded by filter nodes for correctness though)
 
     if (!((always_add_project_if_first_project_is_window_expr &&
            project_node_counter == 1) ||
           filter_node || has_multi_fragment_scan_input)) {
       continue;
     }
 
     RexInputSet inputs;
     RexInputCollector input_collector;
     for (size_t i = 0; i < window_func_project_node->size(); i++) {
       auto new_inputs = input_collector.visit(window_func_project_node->getProjectAt(i));
       inputs.insert(new_inputs.begin(), new_inputs.end());
     }
 
     // Note: Technically not required since we are mapping old inputs to new input
     // indices, but makes the re-mapping of inputs easier to follow.
     std::vector<RexInput> sorted_inputs(inputs.begin(), inputs.end());
     std::sort(sorted_inputs.begin(),
               sorted_inputs.end(),
               [](const auto& a, const auto& b) { return a.getIndex() < b.getIndex(); });
 
     std::vector<std::unique_ptr<const RexScalar>> scalar_exprs;
     std::vector<std::string> fields;
     std::unordered_map<unsigned, unsigned> old_index_to_new_index;
     for (auto& input : sorted_inputs) {
       CHECK_EQ(input.getSourceNode(), prev_node.get());
       CHECK(old_index_to_new_index
                 .insert(std::make_pair(input.getIndex(), scalar_exprs.size()))
                 .second);
       scalar_exprs.emplace_back(input.deepCopy());
       fields.emplace_back("");
     }
 
     auto new_project = std::make_shared<RelProject>(scalar_exprs, fields, prev_node);
     propagate_hints_to_new_project(window_func_project_node, new_project, query_hints);
     node_list.insert(node_itr, new_project);
     window_func_project_node->replaceInput(
         prev_node, new_project, old_index_to_new_index);
   }
 
   nodes.assign(node_list.begin(), node_list.end());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDagBuilder.cpp}::bind_inputs ( const std::vector< std::shared_ptr< RelAlgNode >> & nodes )

noexcept

Definition at line 1198 of file RelAlgDagBuilder.cpp.

References bind_project_to_input(), bind_table_func_to_input(), CHECK_EQ, disambiguate_rex(), get_node_output(), and i.

Referenced by RelAlgDagBuilder::build().

                                                                              {
   for (auto ra_node : nodes) {
     const auto filter_node = std::dynamic_pointer_cast<RelFilter>(ra_node);
     if (filter_node) {
       CHECK_EQ(size_t(1), filter_node->inputCount());
       auto disambiguated_condition = disambiguate_rex(
           filter_node->getCondition(), get_node_output(filter_node->getInput(0)));
       filter_node->setCondition(disambiguated_condition);
       continue;
     }
     const auto join_node = std::dynamic_pointer_cast<RelJoin>(ra_node);
     if (join_node) {
       CHECK_EQ(size_t(2), join_node->inputCount());
       auto disambiguated_condition =
           disambiguate_rex(join_node->getCondition(), get_node_output(join_node.get()));
       join_node->setCondition(disambiguated_condition);
       continue;
     }
     const auto project_node = std::dynamic_pointer_cast<RelProject>(ra_node);
     if (project_node) {
       bind_project_to_input(project_node.get(),
                             get_node_output(project_node->getInput(0)));
       continue;
     }
     const auto table_func_node = std::dynamic_pointer_cast<RelTableFunction>(ra_node);
     if (table_func_node) {
       /*
         Collect all inputs from table function input (non-literal)
         arguments.
       */
       RANodeOutput input;
       input.reserve(table_func_node->inputCount());
       for (size_t i = 0; i < table_func_node->inputCount(); i++) {
         auto node_output = get_node_output(table_func_node->getInput(i));
         input.insert(input.end(), node_output.begin(), node_output.end());
       }
       bind_table_func_to_input(table_func_node.get(), input);
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDagBuilder.cpp}::bind_project_to_input	(	RelProject *	project_node,
		const RANodeOutput &	input
	)

noexcept

Definition at line 1170 of file RelAlgDagBuilder.cpp.

References CHECK_EQ, disambiguate_rex(), and i.

Referenced by bind_inputs(), and create_compound().

                                                                                          {
   CHECK_EQ(size_t(1), project_node->inputCount());
   std::vector<std::unique_ptr<const RexScalar>> disambiguated_exprs;
   for (size_t i = 0; i < project_node->size(); ++i) {
     const auto projected_expr = project_node->getProjectAt(i);
     if (dynamic_cast<const RexSubQuery*>(projected_expr)) {
       disambiguated_exprs.emplace_back(project_node->getProjectAtAndRelease(i));
     } else {
       disambiguated_exprs.emplace_back(disambiguate_rex(projected_expr, input));
     }
   }
   project_node->setExpressions(disambiguated_exprs);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDagBuilder.cpp}::bind_table_func_to_input	(	RelTableFunction *	table_func_node,
		const RANodeOutput &	input
	)

noexcept

Definition at line 1184 of file RelAlgDagBuilder.cpp.

References disambiguate_rex(), and i.

Referenced by bind_inputs().

                                                                   {
   std::vector<std::unique_ptr<const RexScalar>> disambiguated_exprs;
   for (size_t i = 0; i < table_func_node->getTableFuncInputsSize(); ++i) {
     const auto target_expr = table_func_node->getTableFuncInputAt(i);
     if (dynamic_cast<const RexSubQuery*>(target_expr)) {
       disambiguated_exprs.emplace_back(table_func_node->getTableFuncInputAtAndRelease(i));
     } else {
       disambiguated_exprs.emplace_back(disambiguate_rex(target_expr, input));
     }
   }
   table_func_node->setTableFuncInputs(disambiguated_exprs);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDagBuilder.cpp}::check_empty_inputs_field ( const rapidjson::Value & node )

noexcept

Definition at line 2204 of file RelAlgDagBuilder.cpp.

References CHECK, and field().

Referenced by details::RelAlgDispatcher::dispatchTableScan().

                                                                    {
   const auto& inputs_json = field(node, "inputs");
   CHECK(inputs_json.IsArray() && !inputs_json.Size());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDagBuilder.cpp}::coalesce_nodes	(	std::vector< std::shared_ptr< RelAlgNode >> &	nodes,
		const std::vector< const RelAlgNode * > &	left_deep_joins,
		std::unordered_map< size_t, RegisteredQueryHint > &	query_hints
	)

Definition at line 1647 of file RelAlgDagBuilder.cpp.

References anonymous_namespace{RelAlgDagBuilder.cpp}::RANodeIterator::allVisited(), CHECK, CHECK_GE, create_compound(), i, anonymous_namespace{RelAlgDagBuilder.cpp}::anonymous_namespace{RelAlgDagBuilder.cpp}::input_can_be_coalesced(), and gpu_enabled::swap().

Referenced by RelAlgDagBuilder::build().

                                                                                 {
   enum class CoalesceState { Initial, Filter, FirstProject, Aggregate };
   std::vector<size_t> crt_pattern;
   CoalesceState crt_state{CoalesceState::Initial};
 
   auto reset_state = [&crt_pattern, &crt_state]() {
     crt_state = CoalesceState::Initial;
     std::vector<size_t>().swap(crt_pattern);
   };
 
   for (RANodeIterator nodeIt(nodes); !nodeIt.allVisited();) {
     const auto ra_node = nodeIt != nodes.end() ? *nodeIt : nullptr;
     switch (crt_state) {
       case CoalesceState::Initial: {
         if (std::dynamic_pointer_cast<const RelFilter>(ra_node) &&
             std::find(left_deep_joins.begin(), left_deep_joins.end(), ra_node.get()) ==
                 left_deep_joins.end()) {
           crt_pattern.push_back(size_t(nodeIt));
           crt_state = CoalesceState::Filter;
           nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
         } else if (auto project_node =
                        std::dynamic_pointer_cast<const RelProject>(ra_node)) {
           if (project_node->hasWindowFunctionExpr()) {
             nodeIt.advance(RANodeIterator::AdvancingMode::InOrder);
           } else {
             crt_pattern.push_back(size_t(nodeIt));
             crt_state = CoalesceState::FirstProject;
             nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
           }
         } else {
           nodeIt.advance(RANodeIterator::AdvancingMode::InOrder);
         }
         break;
       }
       case CoalesceState::Filter: {
         if (auto project_node = std::dynamic_pointer_cast<const RelProject>(ra_node)) {
           // Given we now add preceding projects for all window functions following
           // RelFilter nodes, the following should never occur
           CHECK(!project_node->hasWindowFunctionExpr());
           crt_pattern.push_back(size_t(nodeIt));
           crt_state = CoalesceState::FirstProject;
           nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
         } else {
           reset_state();
         }
         break;
       }
       case CoalesceState::FirstProject: {
         if (std::dynamic_pointer_cast<const RelAggregate>(ra_node)) {
           crt_pattern.push_back(size_t(nodeIt));
           crt_state = CoalesceState::Aggregate;
           nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
         } else {
           if (crt_pattern.size() >= 2) {
             create_compound(nodes, crt_pattern, query_hints);
           }
           reset_state();
         }
         break;
       }
       case CoalesceState::Aggregate: {
         if (auto project_node = std::dynamic_pointer_cast<const RelProject>(ra_node)) {
           if (!project_node->hasWindowFunctionExpr()) {
             // TODO(adb): overloading the simple project terminology again here
             bool is_simple_project{true};
             for (size_t i = 0; i < project_node->size(); i++) {
               const auto scalar_rex = project_node->getProjectAt(i);
               // If the top level scalar rex is an input node, we can bypass the visitor
               if (auto input_rex = dynamic_cast<const RexInput*>(scalar_rex)) {
                 if (!input_can_be_coalesced(
                         input_rex->getSourceNode(), input_rex->getIndex(), true)) {
                   is_simple_project = false;
                   break;
                 }
                 continue;
               }
               CoalesceSecondaryProjectVisitor visitor;
               if (!visitor.visit(project_node->getProjectAt(i))) {
                 is_simple_project = false;
                 break;
               }
             }
             if (is_simple_project) {
               crt_pattern.push_back(size_t(nodeIt));
               nodeIt.advance(RANodeIterator::AdvancingMode::InOrder);
             }
           }
         }
         CHECK_GE(crt_pattern.size(), size_t(2));
         create_compound(nodes, crt_pattern, query_hints);
         reset_state();
         break;
       }
       default:
         CHECK(false);
     }
   }
   if (crt_state == CoalesceState::FirstProject || crt_state == CoalesceState::Aggregate) {
     if (crt_pattern.size() >= 2) {
       create_compound(nodes, crt_pattern, query_hints);
     }
     CHECK(!crt_pattern.empty());
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::unique_ptr<const RexAgg> > anonymous_namespace{RelAlgDagBuilder.cpp}::copyAggExprs ( std::vector< std::unique_ptr< const RexAgg >> const & agg_exprs )

Definition at line 397 of file RelAlgDagBuilder.cpp.

                                                              {
   std::vector<std::unique_ptr<const RexAgg>> agg_exprs_copy;
   agg_exprs_copy.reserve(agg_exprs.size());
   for (auto const& agg_expr : agg_exprs) {
     agg_exprs_copy.push_back(agg_expr->deepCopy());
   }
   return agg_exprs_copy;
 }

std::vector<std::unique_ptr<const RexScalar> > anonymous_namespace{RelAlgDagBuilder.cpp}::copyRexScalars ( std::vector< std::unique_ptr< const RexScalar >> const & scalar_sources )

Definition at line 407 of file RelAlgDagBuilder.cpp.

References RexVisitorBase< T >::visit().

                                                                      {
   std::vector<std::unique_ptr<const RexScalar>> scalar_sources_copy;
   scalar_sources_copy.reserve(scalar_sources.size());
   RexDeepCopyVisitor copier;
   for (auto const& scalar_source : scalar_sources) {
     scalar_sources_copy.push_back(copier.visit(scalar_source.get()));
   }
   return scalar_sources_copy;
 }

Here is the call graph for this function:

void anonymous_namespace{RelAlgDagBuilder.cpp}::create_compound	(	std::vector< std::shared_ptr< RelAlgNode >> &	nodes,
		const std::vector< size_t > &	pattern,
		std::unordered_map< size_t, RegisteredQueryHint > &	query_hints
	)

noexcept

Definition at line 1330 of file RelAlgDagBuilder.cpp.

References bind_project_to_input(), CHECK, CHECK_EQ, CHECK_GE, CHECK_LE, CHECK_LT, RegisteredQueryHint::defaults(), get_node_output(), RelProject::getFields(), i, anonymous_namespace{RelAlgExecutor.cpp}::is_agg(), anonymous_namespace{RelAlgDagBuilder.cpp}::anonymous_namespace{RelAlgDagBuilder.cpp}::reproject_targets(), and run_benchmark_import::result.

Referenced by coalesce_nodes().

                                                                          {
   CHECK_GE(pattern.size(), size_t(2));
   CHECK_LE(pattern.size(), size_t(4));
 
   std::unique_ptr<const RexScalar> filter_rex;
   std::vector<std::unique_ptr<const RexScalar>> scalar_sources;
   size_t groupby_count{0};
   std::vector<std::string> fields;
   std::vector<const RexAgg*> agg_exprs;
   std::vector<const Rex*> target_exprs;
   bool first_project{true};
   bool is_agg{false};
   RelAlgNode* last_node{nullptr};
 
   std::shared_ptr<ModifyManipulationTarget> manipulation_target;
   size_t node_hash{0};
   bool hint_registered{false};
   RegisteredQueryHint registered_query_hint = RegisteredQueryHint::defaults();
   for (const auto node_idx : pattern) {
     const auto ra_node = nodes[node_idx];
     auto registered_query_hint_it = query_hints.find(ra_node->toHash());
     if (registered_query_hint_it != query_hints.end()) {
       hint_registered = true;
       node_hash = registered_query_hint_it->first;
       registered_query_hint = registered_query_hint_it->second;
     }
     const auto ra_filter = std::dynamic_pointer_cast<RelFilter>(ra_node);
     if (ra_filter) {
       CHECK(!filter_rex);
       filter_rex.reset(ra_filter->getAndReleaseCondition());
       CHECK(filter_rex);
       last_node = ra_node.get();
       continue;
     }
     const auto ra_project = std::dynamic_pointer_cast<RelProject>(ra_node);
     if (ra_project) {
       fields = ra_project->getFields();
       manipulation_target = ra_project;
 
       if (first_project) {
         CHECK_EQ(size_t(1), ra_project->inputCount());
         // Rebind the input of the project to the input of the filter itself
         // since we know that we'll evaluate the filter on the fly, with no
         // intermediate buffer.
         const auto filter_input = dynamic_cast<const RelFilter*>(ra_project->getInput(0));
         if (filter_input) {
           CHECK_EQ(size_t(1), filter_input->inputCount());
           bind_project_to_input(ra_project.get(),
                                 get_node_output(filter_input->getInput(0)));
         }
         scalar_sources = ra_project->getExpressionsAndRelease();
         for (const auto& scalar_expr : scalar_sources) {
           target_exprs.push_back(scalar_expr.get());
         }
         first_project = false;
       } else {
         if (ra_project->isSimple()) {
           target_exprs = reproject_targets(ra_project.get(), target_exprs);
         } else {
           // TODO(adb): This is essentially a more general case of simple project, we
           // could likely merge the two
           std::vector<const Rex*> result;
           RexInputReplacementVisitor visitor(last_node, scalar_sources);
           for (size_t i = 0; i < ra_project->size(); ++i) {
             const auto rex = ra_project->getProjectAt(i);
             if (auto rex_input = dynamic_cast<const RexInput*>(rex)) {
               const auto index = rex_input->getIndex();
               CHECK_LT(index, target_exprs.size());
               result.push_back(target_exprs[index]);
             } else {
               scalar_sources.push_back(visitor.visit(rex));
               result.push_back(scalar_sources.back().get());
             }
           }
           target_exprs = result;
         }
       }
       last_node = ra_node.get();
       continue;
     }
     const auto ra_aggregate = std::dynamic_pointer_cast<RelAggregate>(ra_node);
     if (ra_aggregate) {
       is_agg = true;
       fields = ra_aggregate->getFields();
       agg_exprs = ra_aggregate->getAggregatesAndRelease();
       groupby_count = ra_aggregate->getGroupByCount();
       decltype(target_exprs){}.swap(target_exprs);
       CHECK_LE(groupby_count, scalar_sources.size());
       for (size_t group_idx = 0; group_idx < groupby_count; ++group_idx) {
         const auto rex_ref = new RexRef(group_idx + 1);
         target_exprs.push_back(rex_ref);
         scalar_sources.emplace_back(rex_ref);
       }
       for (const auto rex_agg : agg_exprs) {
         target_exprs.push_back(rex_agg);
       }
       last_node = ra_node.get();
       continue;
     }
   }
 
   auto compound_node =
       std::make_shared<RelCompound>(filter_rex,
                                     target_exprs,
                                     groupby_count,
                                     agg_exprs,
                                     fields,
                                     scalar_sources,
                                     is_agg,
                                     manipulation_target->isUpdateViaSelect(),
                                     manipulation_target->isDeleteViaSelect(),
                                     manipulation_target->isVarlenUpdateRequired(),
                                     manipulation_target->getModifiedTableDescriptor(),
                                     manipulation_target->getTargetColumns());
   auto old_node = nodes[pattern.back()];
   nodes[pattern.back()] = compound_node;
   auto first_node = nodes[pattern.front()];
   CHECK_EQ(size_t(1), first_node->inputCount());
   compound_node->addManagedInput(first_node->getAndOwnInput(0));
   if (hint_registered) {
     // pass the registered hint from the origin node to newly created compound node
     // where it is coalesced
     query_hints.erase(node_hash);
     query_hints.emplace(compound_node->toHash(), registered_query_hint);
   }
   for (size_t i = 0; i < pattern.size() - 1; ++i) {
     nodes[pattern[i]].reset();
   }
   for (auto node : nodes) {
     if (!node) {
       continue;
     }
     node->replaceInput(old_node, compound_node);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<const RexCase> anonymous_namespace{RelAlgDagBuilder.cpp}::disambiguate_case	(	const RexCase *	rex_case,
		const RANodeOutput &	ra_output
	)

Definition at line 1128 of file RelAlgDagBuilder.cpp.

References RexCase::branchCount(), disambiguate_rex(), RexCase::getElse(), RexCase::getThen(), RexCase::getWhen(), and i.

Referenced by disambiguate_rex().

                                                                                 {
   std::vector<
       std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
       disambiguated_expr_pair_list;
   for (size_t i = 0; i < rex_case->branchCount(); ++i) {
     auto disambiguated_when = disambiguate_rex(rex_case->getWhen(i), ra_output);
     auto disambiguated_then = disambiguate_rex(rex_case->getThen(i), ra_output);
     disambiguated_expr_pair_list.emplace_back(std::move(disambiguated_when),
                                               std::move(disambiguated_then));
   }
   std::unique_ptr<const RexScalar> disambiguated_else{
       disambiguate_rex(rex_case->getElse(), ra_output)};
   return std::unique_ptr<const RexCase>(
       new RexCase(disambiguated_expr_pair_list, disambiguated_else));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<const RexOperator> anonymous_namespace{RelAlgDagBuilder.cpp}::disambiguate_operator	(	const RexOperator *	rex_operator,
		const RANodeOutput &	ra_output
	)

noexcept

Definition at line 1093 of file RelAlgDagBuilder.cpp.

References disambiguate_rex(), RexWindowFunctionOperator::getPartitionKeys(), and i.

Referenced by disambiguate_rex().

                                             {
   std::vector<std::unique_ptr<const RexScalar>> disambiguated_operands;
   for (size_t i = 0; i < rex_operator->size(); ++i) {
     auto operand = rex_operator->getOperand(i);
     if (dynamic_cast<const RexSubQuery*>(operand)) {
       disambiguated_operands.emplace_back(rex_operator->getOperandAndRelease(i));
     } else {
       disambiguated_operands.emplace_back(disambiguate_rex(operand, ra_output));
     }
   }
   const auto rex_window_function_operator =
       dynamic_cast<const RexWindowFunctionOperator*>(rex_operator);
   if (rex_window_function_operator) {
     const auto& partition_keys = rex_window_function_operator->getPartitionKeys();
     std::vector<std::unique_ptr<const RexScalar>> disambiguated_partition_keys;
     for (const auto& partition_key : partition_keys) {
       disambiguated_partition_keys.emplace_back(
           disambiguate_rex(partition_key.get(), ra_output));
     }
     std::vector<std::unique_ptr<const RexScalar>> disambiguated_order_keys;
     const auto& order_keys = rex_window_function_operator->getOrderKeys();
     for (const auto& order_key : order_keys) {
       disambiguated_order_keys.emplace_back(disambiguate_rex(order_key.get(), ra_output));
     }
     return rex_window_function_operator->disambiguatedOperands(
         disambiguated_operands,
         disambiguated_partition_keys,
         disambiguated_order_keys,
         rex_window_function_operator->getCollation());
   }
   return rex_operator->getDisambiguated(disambiguated_operands);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr< const RexScalar > anonymous_namespace{RelAlgDagBuilder.cpp}::disambiguate_rex	(	const RexScalar *	rex_scalar,
		const RANodeOutput &	ra_output
	)

Definition at line 1149 of file RelAlgDagBuilder.cpp.

References CHECK, CHECK_LT, disambiguate_case(), and disambiguate_operator().

Referenced by bind_inputs(), bind_project_to_input(), bind_table_func_to_input(), disambiguate_case(), and disambiguate_operator().

                                                                                  {
   const auto rex_abstract_input = dynamic_cast<const RexAbstractInput*>(rex_scalar);
   if (rex_abstract_input) {
     CHECK_LT(static_cast<size_t>(rex_abstract_input->getIndex()), ra_output.size());
     return std::unique_ptr<const RexInput>(
         new RexInput(ra_output[rex_abstract_input->getIndex()]));
   }
   const auto rex_operator = dynamic_cast<const RexOperator*>(rex_scalar);
   if (rex_operator) {
     return disambiguate_operator(rex_operator, ra_output);
   }
   const auto rex_case = dynamic_cast<const RexCase*>(rex_scalar);
   if (rex_case) {
     return disambiguate_case(rex_case, ra_output);
   }
   const auto rex_literal = dynamic_cast<const RexLiteral*>(rex_scalar);
   CHECK(rex_literal);
   return std::unique_ptr<const RexLiteral>(new RexLiteral(*rex_literal));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::set<std::pair<const RelAlgNode*, int> > anonymous_namespace{RelAlgDagBuilder.cpp}::get_equiv_cols	(	const RelAlgNode *	node,
		const size_t	which_col
	)

Definition at line 520 of file RelAlgDagBuilder.cpp.

References CHECK, and CHECK_EQ.

Referenced by RelSort::hasEquivCollationOf().

                                                                                    {
   std::set<std::pair<const RelAlgNode*, int>> work_set;
   auto walker = node;
   auto curr_col = which_col;
   while (true) {
     work_set.insert(std::make_pair(walker, curr_col));
     if (dynamic_cast<const RelScan*>(walker) || dynamic_cast<const RelJoin*>(walker)) {
       break;
     }
     CHECK_EQ(size_t(1), walker->inputCount());
     auto only_source = walker->getInput(0);
     if (auto project = dynamic_cast<const RelProject*>(walker)) {
       if (auto input = dynamic_cast<const RexInput*>(project->getProjectAt(curr_col))) {
         const auto join_source = dynamic_cast<const RelJoin*>(only_source);
         if (join_source) {
           CHECK_EQ(size_t(2), join_source->inputCount());
           auto lhs = join_source->getInput(0);
           CHECK((input->getIndex() < lhs->size() && lhs == input->getSourceNode()) ||
                 join_source->getInput(1) == input->getSourceNode());
         } else {
           CHECK_EQ(input->getSourceNode(), only_source);
         }
         curr_col = input->getIndex();
       } else {
         break;
       }
     } else if (auto aggregate = dynamic_cast<const RelAggregate*>(walker)) {
       if (curr_col >= aggregate->getGroupByCount()) {
         break;
       }
     }
     walker = only_source;
   }
   return work_set;
 }

Here is the caller graph for this function:

int64_t anonymous_namespace{RelAlgDagBuilder.cpp}::get_int_literal_field	(	const rapidjson::Value &	obj,
		const char	field[],
		const int64_t	default_val
	)

noexcept

Definition at line 2190 of file RelAlgDagBuilder.cpp.

References CHECK_EQ, field(), kDECIMAL, and parse_literal().

Referenced by details::RelAlgDispatcher::dispatchSort().

                                                                   {
   const auto it = obj.FindMember(field);
   if (it == obj.MemberEnd()) {
     return default_val;
   }
   std::unique_ptr<RexLiteral> lit(parse_literal(it->value));
   CHECK_EQ(kDECIMAL, lit->getType());
   CHECK_EQ(unsigned(0), lit->getScale());
   CHECK_EQ(unsigned(0), lit->getTargetScale());
   return lit->getVal<int64_t>();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::string> anonymous_namespace{RelAlgDagBuilder.cpp}::getFieldNamesFromScanNode ( const rapidjson::Value & scan_ra )

Definition at line 2219 of file RelAlgDagBuilder.cpp.

References field(), and strings_from_json_array().

Referenced by details::RelAlgDispatcher::dispatchTableScan().

                                                                               {
   const auto& fields_json = field(scan_ra, "fieldNames");
   return strings_from_json_array(fields_json);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const TableDescriptor* anonymous_namespace{RelAlgDagBuilder.cpp}::getTableFromScanNode	(	const Catalog_Namespace::Catalog &	cat,
		const rapidjson::Value &	scan_ra
	)

Definition at line 2209 of file RelAlgDagBuilder.cpp.

References CHECK, CHECK_EQ, field(), and Catalog_Namespace::Catalog::getMetadataForTable().

Referenced by details::RelAlgDispatcher::dispatchModify(), and details::RelAlgDispatcher::dispatchTableScan().

                                                                            {
   const auto& table_json = field(scan_ra, "table");
   CHECK(table_json.IsArray());
   CHECK_EQ(unsigned(2), table_json.Size());
   const auto td = cat.getMetadataForTable(table_json[1].GetString());
   CHECK(td);
   return td;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDagBuilder.cpp}::handleQueryHint	(	const std::vector< std::shared_ptr< RelAlgNode >> &	nodes,
		RelAlgDagBuilder *	dag_builder
	)

noexcept

Definition at line 1239 of file RelAlgDagBuilder.cpp.

References RelProject::getDeliveredHints(), RelAggregate::getDeliveredHints(), and RelCompound::getDeliveredHints().

Referenced by RelAlgDagBuilder::build().

                                                              {
   // query hint is delivered by the above three nodes
   // when a query block has top-sort node, a hint is registered to
   // one of the node which locates at the nearest from the sort node
   for (auto node : nodes) {
     Hints* hint_delivered = nullptr;
     const auto agg_node = std::dynamic_pointer_cast<RelAggregate>(node);
     if (agg_node) {
       if (agg_node->hasDeliveredHint()) {
         hint_delivered = agg_node->getDeliveredHints();
       }
     }
     const auto project_node = std::dynamic_pointer_cast<RelProject>(node);
     if (project_node) {
       if (project_node->hasDeliveredHint()) {
         hint_delivered = project_node->getDeliveredHints();
       }
     }
     const auto compound_node = std::dynamic_pointer_cast<RelCompound>(node);
     if (compound_node) {
       if (compound_node->hasDeliveredHint()) {
         hint_delivered = compound_node->getDeliveredHints();
       }
     }
     if (hint_delivered && !hint_delivered->empty()) {
       dag_builder->registerQueryHints(node, hint_delivered);
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<size_t> anonymous_namespace{RelAlgDagBuilder.cpp}::indices_from_json_array ( const rapidjson::Value & json_idx_arr )

noexcept

Definition at line 1021 of file RelAlgDagBuilder.cpp.

References CHECK, and CHECK_GE.

Referenced by details::RelAlgDispatcher::dispatchAggregate(), and parse_aggregate_expr().

                                                  {
   CHECK(json_idx_arr.IsArray());
   std::vector<size_t> indices;
   for (auto json_idx_arr_it = json_idx_arr.Begin(); json_idx_arr_it != json_idx_arr.End();
        ++json_idx_arr_it) {
     CHECK(json_idx_arr_it->IsInt());
     CHECK_GE(json_idx_arr_it->GetInt(), 0);
     indices.emplace_back(json_idx_arr_it->GetInt());
   }
   return indices;
 }

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgDagBuilder.cpp}::isRenamedInput	(	const RelAlgNode *	node,
		const size_t	index,
		const std::string &	new_name
	)

Definition at line 251 of file RelAlgDagBuilder.cpp.

References CHECK, CHECK_EQ, CHECK_GE, CHECK_LT, RelAlgNode::getInput(), join(), and RelAlgNode::size().

Referenced by RelProject::isRenaming().

                                                {
   CHECK_LT(index, node->size());
   if (auto join = dynamic_cast<const RelJoin*>(node)) {
     CHECK_EQ(size_t(2), join->inputCount());
     const auto lhs_size = join->getInput(0)->size();
     if (index < lhs_size) {
       return isRenamedInput(join->getInput(0), index, new_name);
     }
     CHECK_GE(index, lhs_size);
     return isRenamedInput(join->getInput(1), index - lhs_size, new_name);
   }
 
   if (auto scan = dynamic_cast<const RelScan*>(node)) {
     return new_name != scan->getFieldName(index);
   }
 
   if (auto aggregate = dynamic_cast<const RelAggregate*>(node)) {
     return new_name != aggregate->getFieldName(index);
   }
 
   if (auto project = dynamic_cast<const RelProject*>(node)) {
     return new_name != project->getFieldName(index);
   }
 
   if (auto table_func = dynamic_cast<const RelTableFunction*>(node)) {
     return new_name != table_func->getFieldName(index);
   }
 
   if (auto logical_values = dynamic_cast<const RelLogicalValues*>(node)) {
     const auto& tuple_type = logical_values->getTupleType();
     CHECK_LT(index, tuple_type.size());
     return new_name != tuple_type[index].get_resname();
   }
 
   CHECK(dynamic_cast<const RelSort*>(node) || dynamic_cast<const RelFilter*>(node) ||
         dynamic_cast<const RelLogicalUnion*>(node));
   return isRenamedInput(node->getInput(0), index, new_name);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string anonymous_namespace{RelAlgDagBuilder.cpp}::json_node_to_string ( const rapidjson::Value & node )

noexcept

Definition at line 686 of file RelAlgDagBuilder.cpp.

Referenced by details::RelAlgDispatcher::dispatchModify(), parse_scalar_expr(), and parse_type().

                                                                    {
   rapidjson::StringBuffer buffer;
   rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
   node.Accept(writer);
   return buffer.GetString();
 }

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDagBuilder.cpp}::mark_nops ( const std::vector< std::shared_ptr< RelAlgNode >> & nodes )

noexcept

Definition at line 1270 of file RelAlgDagBuilder.cpp.

References CHECK_EQ, and RelAlgNode::markAsNop().

Referenced by RelAlgDagBuilder::build().

                                                                            {
   for (auto node : nodes) {
     const auto agg_node = std::dynamic_pointer_cast<RelAggregate>(node);
     if (!agg_node || agg_node->getAggExprsCount()) {
       continue;
     }
     CHECK_EQ(size_t(1), node->inputCount());
     const auto agg_input_node = dynamic_cast<const RelAggregate*>(node->getInput(0));
     if (agg_input_node && !agg_input_node->getAggExprsCount() &&
         agg_node->getGroupByCount() == agg_input_node->getGroupByCount()) {
       agg_node->markAsNop();
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<RexInput> anonymous_namespace{RelAlgDagBuilder.cpp}::n_outputs	(	const RelAlgNode *	node,
		const size_t	n
	)

Definition at line 96 of file RelAlgDagBuilder.cpp.

References i, and anonymous_namespace{Utm.h}::n.

Referenced by get_node_output().

                                                                       {
   std::vector<RexInput> outputs;
   outputs.reserve(n);
   for (size_t i = 0; i < n; ++i) {
     outputs.emplace_back(node, i);
   }
   return outputs;
 }

Here is the caller graph for this function:

unsigned anonymous_namespace{RelAlgDagBuilder.cpp}::node_id ( const rapidjson::Value & ra_node )

noexcept

Definition at line 681 of file RelAlgDagBuilder.cpp.

References field(), and json_str().

Referenced by details::RelAlgDispatcher::dispatchFilter(), details::RelAlgDispatcher::prev(), and details::RelAlgDispatcher::run().

                                                          {
   const auto& id = field(ra_node, "id");
   return std::stoi(json_str(id));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<RexAbstractInput> anonymous_namespace{RelAlgDagBuilder.cpp}::parse_abstract_input ( const rapidjson::Value & expr )

noexcept

Definition at line 697 of file RelAlgDagBuilder.cpp.

References field(), and json_i64().

Referenced by parse_scalar_expr().

                                          {
   const auto& input = field(expr, "input");
   return std::unique_ptr<RexAbstractInput>(new RexAbstractInput(json_i64(input)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<const RexAgg> anonymous_namespace{RelAlgDagBuilder.cpp}::parse_aggregate_expr ( const rapidjson::Value & expr )

Definition at line 1034 of file RelAlgDagBuilder.cpp.

References field(), indices_from_json_array(), logger::INFO, json_bool(), json_str(), kAPPROX_COUNT_DISTINCT, kAPPROX_QUANTILE, LOG, parse_type(), and to_agg_kind().

Referenced by details::RelAlgDispatcher::dispatchAggregate().

                                                                              {
   const auto agg_str = json_str(field(expr, "agg"));
   if (agg_str == "APPROX_QUANTILE") {
     LOG(INFO) << "APPROX_QUANTILE is deprecated. Please use APPROX_PERCENTILE instead.";
   }
   const auto agg = to_agg_kind(agg_str);
   const auto distinct = json_bool(field(expr, "distinct"));
   const auto agg_ti = parse_type(field(expr, "type"));
   const auto operands = indices_from_json_array(field(expr, "operands"));
   if (operands.size() > 1 && (operands.size() != 2 || (agg != kAPPROX_COUNT_DISTINCT &&
                                                        agg != kAPPROX_QUANTILE))) {
     throw QueryNotSupported("Multiple arguments for aggregates aren't supported");
   }
   return std::unique_ptr<const RexAgg>(new RexAgg(agg, distinct, agg_ti, operands));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<RexCase> anonymous_namespace{RelAlgDagBuilder.cpp}::parse_case	(	const rapidjson::Value &	expr,
		const Catalog_Namespace::Catalog &	cat,
		RelAlgDagBuilder &	root_dag_builder
	)

Definition at line 987 of file RelAlgDagBuilder.cpp.

References CHECK, CHECK_GE, field(), and parse_scalar_expr().

Referenced by parse_scalar_expr().

                                                                         {
   const auto& operands = field(expr, "operands");
   CHECK(operands.IsArray());
   CHECK_GE(operands.Size(), unsigned(2));
   std::unique_ptr<const RexScalar> else_expr;
   std::vector<
       std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
       expr_pair_list;
   for (auto operands_it = operands.Begin(); operands_it != operands.End();) {
     auto when_expr = parse_scalar_expr(*operands_it++, cat, root_dag_builder);
     if (operands_it == operands.End()) {
       else_expr = std::move(when_expr);
       break;
     }
     auto then_expr = parse_scalar_expr(*operands_it++, cat, root_dag_builder);
     expr_pair_list.emplace_back(std::move(when_expr), std::move(then_expr));
   }
   return std::unique_ptr<RexCase>(new RexCase(expr_pair_list, else_expr));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::unique_ptr<const RexScalar> > anonymous_namespace{RelAlgDagBuilder.cpp}::parse_expr_array	(	const rapidjson::Value &	arr,
		const Catalog_Namespace::Catalog &	cat,
		RelAlgDagBuilder &	root_dag_builder
	)

Definition at line 808 of file RelAlgDagBuilder.cpp.

References parse_scalar_expr().

Referenced by parse_operator().

                                         {
   std::vector<std::unique_ptr<const RexScalar>> exprs;
   for (auto it = arr.Begin(); it != arr.End(); ++it) {
     exprs.emplace_back(parse_scalar_expr(*it, cat, root_dag_builder));
   }
   return exprs;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<RexLiteral> anonymous_namespace{RelAlgDagBuilder.cpp}::parse_literal ( const rapidjson::Value & expr )

Definition at line 703 of file RelAlgDagBuilder.cpp.

References CHECK, field(), json_bool(), json_double(), json_i64(), json_str(), kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNULLT, kTEXT, kTIME, kTIMESTAMP, to_sql_type(), run_benchmark_import::type, and UNREACHABLE.

Referenced by details::RelAlgDispatcher::dispatchLogicalValues(), get_int_literal_field(), and parse_scalar_expr().

                                                                     {
   CHECK(expr.IsObject());
   const auto& literal = field(expr, "literal");
   const auto type = to_sql_type(json_str(field(expr, "type")));
   const auto target_type = to_sql_type(json_str(field(expr, "target_type")));
   const auto scale = json_i64(field(expr, "scale"));
   const auto precision = json_i64(field(expr, "precision"));
   const auto type_scale = json_i64(field(expr, "type_scale"));
   const auto type_precision = json_i64(field(expr, "type_precision"));
   if (literal.IsNull()) {
     return std::unique_ptr<RexLiteral>(new RexLiteral(target_type));
   }
   switch (type) {
     case kINT:
     case kBIGINT:
     case kDECIMAL:
     case kINTERVAL_DAY_TIME:
     case kINTERVAL_YEAR_MONTH:
     case kTIME:
     case kTIMESTAMP:
     case kDATE:
       return std::unique_ptr<RexLiteral>(new RexLiteral(json_i64(literal),
                                                         type,
                                                         target_type,
                                                         scale,
                                                         precision,
                                                         type_scale,
                                                         type_precision));
     case kDOUBLE: {
       if (literal.IsDouble()) {
         return std::unique_ptr<RexLiteral>(new RexLiteral(json_double(literal),
                                                           type,
                                                           target_type,
                                                           scale,
                                                           precision,
                                                           type_scale,
                                                           type_precision));
       } else if (literal.IsInt64()) {
         return std::make_unique<RexLiteral>(static_cast<double>(literal.GetInt64()),
                                             type,
                                             target_type,
                                             scale,
                                             precision,
                                             type_scale,
                                             type_precision);
 
       } else if (literal.IsUint64()) {
         return std::make_unique<RexLiteral>(static_cast<double>(literal.GetUint64()),
                                             type,
                                             target_type,
                                             scale,
                                             precision,
                                             type_scale,
                                             type_precision);
       }
       UNREACHABLE() << "Unhandled type: " << literal.GetType();
     }
     case kTEXT:
       return std::unique_ptr<RexLiteral>(new RexLiteral(json_str(literal),
                                                         type,
                                                         target_type,
                                                         scale,
                                                         precision,
                                                         type_scale,
                                                         type_precision));
     case kBOOLEAN:
       return std::unique_ptr<RexLiteral>(new RexLiteral(json_bool(literal),
                                                         type,
                                                         target_type,
                                                         scale,
                                                         precision,
                                                         type_scale,
                                                         type_precision));
     case kNULLT:
       return std::unique_ptr<RexLiteral>(new RexLiteral(target_type));
     default:
       CHECK(false);
   }
   CHECK(false);
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

NullSortedPosition anonymous_namespace{RelAlgDagBuilder.cpp}::parse_nulls_position ( const rapidjson::Value & collation )

Definition at line 888 of file RelAlgDagBuilder.cpp.

References field(), First, json_str(), and Last.

Referenced by details::RelAlgDispatcher::dispatchSort(), and parse_window_order_collation().

                                                                          {
   return json_str(field(collation, "nulls")) == std::string("FIRST")
              ? NullSortedPosition::First
              : NullSortedPosition::Last;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<RexOperator> anonymous_namespace{RelAlgDagBuilder.cpp}::parse_operator	(	const rapidjson::Value &	expr,
		const Catalog_Namespace::Catalog &	cat,
		RelAlgDagBuilder &	root_dag_builder
	)

Definition at line 941 of file RelAlgDagBuilder.cpp.

References CHECK, field(), json_bool(), json_str(), kFUNCTION, kIN, gpu_enabled::lower_bound(), parse_expr_array(), parse_subquery(), parse_type(), parse_window_bound(), parse_window_function_kind(), parse_window_order_collation(), parse_window_order_exprs(), to_sql_op(), and gpu_enabled::upper_bound().

Referenced by parse_scalar_expr().

                                                                                 {
   const auto op_name = json_str(field(expr, "op"));
   const bool is_quantifier =
       op_name == std::string("PG_ANY") || op_name == std::string("PG_ALL");
   const auto op = is_quantifier ? kFUNCTION : to_sql_op(op_name);
   const auto& operators_json_arr = field(expr, "operands");
   CHECK(operators_json_arr.IsArray());
   auto operands = parse_expr_array(operators_json_arr, cat, root_dag_builder);
   const auto type_it = expr.FindMember("type");
   CHECK(type_it != expr.MemberEnd());
   auto ti = parse_type(type_it->value);
   if (op == kIN && expr.HasMember("subquery")) {
     auto subquery = parse_subquery(expr, cat, root_dag_builder);
     operands.emplace_back(std::move(subquery));
   }
   if (expr.FindMember("partition_keys") != expr.MemberEnd()) {
     const auto& partition_keys_arr = field(expr, "partition_keys");
     auto partition_keys = parse_expr_array(partition_keys_arr, cat, root_dag_builder);
     const auto& order_keys_arr = field(expr, "order_keys");
     auto order_keys = parse_window_order_exprs(order_keys_arr, cat, root_dag_builder);
     const auto collation =
         parse_window_order_collation(order_keys_arr, cat, root_dag_builder);
     const auto kind = parse_window_function_kind(op_name);
     const auto lower_bound =
         parse_window_bound(field(expr, "lower_bound"), cat, root_dag_builder);
     const auto upper_bound =
         parse_window_bound(field(expr, "upper_bound"), cat, root_dag_builder);
     bool is_rows = json_bool(field(expr, "is_rows"));
     ti.set_notnull(false);
     return std::make_unique<RexWindowFunctionOperator>(kind,
                                                        operands,
                                                        partition_keys,
                                                        order_keys,
                                                        collation,
                                                        lower_bound,
                                                        upper_bound,
                                                        is_rows,
                                                        ti);
   }
   return std::unique_ptr<RexOperator>(op == kFUNCTION
                                           ? new RexFunctionOperator(op_name, operands, ti)
                                           : new RexOperator(op, operands, ti));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr< const RexScalar > anonymous_namespace{RelAlgDagBuilder.cpp}::parse_scalar_expr	(	const rapidjson::Value &	expr,
		const Catalog_Namespace::Catalog &	cat,
		RelAlgDagBuilder &	root_dag_builder
	)

Definition at line 1050 of file RelAlgDagBuilder.cpp.

References CHECK, field(), json_node_to_string(), json_str(), parse_abstract_input(), parse_case(), parse_literal(), parse_operator(), and parse_subquery().

Referenced by details::RelAlgDispatcher::dispatchFilter(), details::RelAlgDispatcher::dispatchJoin(), details::RelAlgDispatcher::dispatchProject(), details::RelAlgDispatcher::dispatchTableFunction(), parse_case(), parse_expr_array(), parse_window_bound(), and parse_window_order_exprs().

                                                                                        {
   CHECK(expr.IsObject());
   if (expr.IsObject() && expr.HasMember("input")) {
     return std::unique_ptr<const RexScalar>(parse_abstract_input(expr));
   }
   if (expr.IsObject() && expr.HasMember("literal")) {
     return std::unique_ptr<const RexScalar>(parse_literal(expr));
   }
   if (expr.IsObject() && expr.HasMember("op")) {
     const auto op_str = json_str(field(expr, "op"));
     if (op_str == std::string("CASE")) {
       return std::unique_ptr<const RexScalar>(parse_case(expr, cat, root_dag_builder));
     }
     if (op_str == std::string("$SCALAR_QUERY")) {
       return std::unique_ptr<const RexScalar>(
           parse_subquery(expr, cat, root_dag_builder));
     }
     return std::unique_ptr<const RexScalar>(parse_operator(expr, cat, root_dag_builder));
   }
   throw QueryNotSupported("Expression node " + json_node_to_string(expr) +
                           " not supported");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SortDirection anonymous_namespace{RelAlgDagBuilder.cpp}::parse_sort_direction ( const rapidjson::Value & collation )

Definition at line 882 of file RelAlgDagBuilder.cpp.

References Ascending, Descending, field(), and json_str().

Referenced by details::RelAlgDispatcher::dispatchSort(), and parse_window_order_collation().

                                                                     {
   return json_str(field(collation, "direction")) == std::string("DESCENDING")
              ? SortDirection::Descending
              : SortDirection::Ascending;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<const RexSubQuery> anonymous_namespace{RelAlgDagBuilder.cpp}::parse_subquery	(	const rapidjson::Value &	expr,
		const Catalog_Namespace::Catalog &	cat,
		RelAlgDagBuilder &	root_dag_builder
	)

Definition at line 927 of file RelAlgDagBuilder.cpp.

References CHECK, CHECK_GE, field(), RelAlgDagBuilder::getRootNodeShPtr(), and RelAlgDagBuilder::registerSubquery().

Referenced by parse_operator(), and parse_scalar_expr().

                                                                                       {
   const auto& operands = field(expr, "operands");
   CHECK(operands.IsArray());
   CHECK_GE(operands.Size(), unsigned(0));
   const auto& subquery_ast = field(expr, "subquery");
 
   RelAlgDagBuilder subquery_dag(root_dag_builder, subquery_ast, cat, nullptr);
   auto subquery = std::make_shared<RexSubQuery>(subquery_dag.getRootNodeShPtr());
   root_dag_builder.registerSubquery(subquery);
   return subquery->deepCopy();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SQLTypeInfo anonymous_namespace{RelAlgDagBuilder.cpp}::parse_type ( const rapidjson::Value & type_obj )

Definition at line 789 of file RelAlgDagBuilder.cpp.

References CHECK, field(), json_bool(), json_i64(), json_node_to_string(), json_str(), SQLTypeInfo::set_precision(), SQLTypeInfo::set_scale(), to_sql_type(), and run_benchmark_import::type.

Referenced by details::RelAlgDispatcher::dispatchLogicalValues(), parse_aggregate_expr(), and parse_operator().

                                                        {
   if (type_obj.IsArray()) {
     throw QueryNotSupported("Composite types are not currently supported.");
   }
   CHECK(type_obj.IsObject() && type_obj.MemberCount() >= 2)
       << json_node_to_string(type_obj);
   const auto type = to_sql_type(json_str(field(type_obj, "type")));
   const auto nullable = json_bool(field(type_obj, "nullable"));
   const auto precision_it = type_obj.FindMember("precision");
   const int precision =
       precision_it != type_obj.MemberEnd() ? json_i64(precision_it->value) : 0;
   const auto scale_it = type_obj.FindMember("scale");
   const int scale = scale_it != type_obj.MemberEnd() ? json_i64(scale_it->value) : 0;
   SQLTypeInfo ti(type, !nullable);
   ti.set_precision(precision);
   ti.set_scale(scale);
   return ti;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

RexWindowFunctionOperator::RexWindowBound anonymous_namespace{RelAlgDagBuilder.cpp}::parse_window_bound	(	const rapidjson::Value &	window_bound_obj,
		const Catalog_Namespace::Catalog &	cat,
		RelAlgDagBuilder &	root_dag_builder
	)

Definition at line 907 of file RelAlgDagBuilder.cpp.

References CHECK, field(), json_bool(), json_i64(), parse_scalar_expr(), and RexWindowFunctionOperator::RexWindowBound::unbounded.

Referenced by parse_operator().

                                         {
   CHECK(window_bound_obj.IsObject());
   RexWindowFunctionOperator::RexWindowBound window_bound;
   window_bound.unbounded = json_bool(field(window_bound_obj, "unbounded"));
   window_bound.preceding = json_bool(field(window_bound_obj, "preceding"));
   window_bound.following = json_bool(field(window_bound_obj, "following"));
   window_bound.is_current_row = json_bool(field(window_bound_obj, "is_current_row"));
   const auto& offset_field = field(window_bound_obj, "offset");
   if (offset_field.IsObject()) {
     window_bound.offset = parse_scalar_expr(offset_field, cat, root_dag_builder);
   } else {
     CHECK(offset_field.IsNull());
   }
   window_bound.order_key = json_i64(field(window_bound_obj, "order_key"));
   return window_bound;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlWindowFunctionKind anonymous_namespace{RelAlgDagBuilder.cpp}::parse_window_function_kind ( const std::string & name )

Definition at line 819 of file RelAlgDagBuilder.cpp.

References AVG, COUNT, CUME_DIST, DENSE_RANK, FIRST_VALUE, LAG, LAST_VALUE, LEAD, MAX, MIN, NTILE, PERCENT_RANK, RANK, ROW_NUMBER, SUM, and SUM_INTERNAL.

Referenced by parse_operator().

                                                                         {
   if (name == "ROW_NUMBER") {
     return SqlWindowFunctionKind::ROW_NUMBER;
   }
   if (name == "RANK") {
     return SqlWindowFunctionKind::RANK;
   }
   if (name == "DENSE_RANK") {
     return SqlWindowFunctionKind::DENSE_RANK;
   }
   if (name == "PERCENT_RANK") {
     return SqlWindowFunctionKind::PERCENT_RANK;
   }
   if (name == "CUME_DIST") {
     return SqlWindowFunctionKind::CUME_DIST;
   }
   if (name == "NTILE") {
     return SqlWindowFunctionKind::NTILE;
   }
   if (name == "LAG") {
     return SqlWindowFunctionKind::LAG;
   }
   if (name == "LEAD") {
     return SqlWindowFunctionKind::LEAD;
   }
   if (name == "FIRST_VALUE") {
     return SqlWindowFunctionKind::FIRST_VALUE;
   }
   if (name == "LAST_VALUE") {
     return SqlWindowFunctionKind::LAST_VALUE;
   }
   if (name == "AVG") {
     return SqlWindowFunctionKind::AVG;
   }
   if (name == "MIN") {
     return SqlWindowFunctionKind::MIN;
   }
   if (name == "MAX") {
     return SqlWindowFunctionKind::MAX;
   }
   if (name == "SUM") {
     return SqlWindowFunctionKind::SUM;
   }
   if (name == "COUNT") {
     return SqlWindowFunctionKind::COUNT;
   }
   if (name == "$SUM0") {
     return SqlWindowFunctionKind::SUM_INTERNAL;
   }
   throw std::runtime_error("Unsupported window function: " + name);
 }

Here is the caller graph for this function:

std::vector<SortField> anonymous_namespace{RelAlgDagBuilder.cpp}::parse_window_order_collation	(	const rapidjson::Value &	arr,
		const Catalog_Namespace::Catalog &	cat,
		RelAlgDagBuilder &	root_dag_builder
	)

Definition at line 894 of file RelAlgDagBuilder.cpp.

References parse_nulls_position(), and parse_sort_direction().

Referenced by parse_operator().

                                                                                         {
   std::vector<SortField> collation;
   size_t field_idx = 0;
   for (auto it = arr.Begin(); it != arr.End(); ++it, ++field_idx) {
     const auto sort_dir = parse_sort_direction(*it);
     const auto null_pos = parse_nulls_position(*it);
     collation.emplace_back(field_idx, sort_dir, null_pos);
   }
   return collation;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::unique_ptr<const RexScalar> > anonymous_namespace{RelAlgDagBuilder.cpp}::parse_window_order_exprs	(	const rapidjson::Value &	arr,
		const Catalog_Namespace::Catalog &	cat,
		RelAlgDagBuilder &	root_dag_builder
	)

Definition at line 871 of file RelAlgDagBuilder.cpp.

References field(), and parse_scalar_expr().

Referenced by parse_operator().

                                         {
   std::vector<std::unique_ptr<const RexScalar>> exprs;
   for (auto it = arr.Begin(); it != arr.End(); ++it) {
     exprs.emplace_back(parse_scalar_expr(field(*it, "field"), cat, root_dag_builder));
   }
   return exprs;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDagBuilder.cpp}::propagate_hints_to_new_project	(	std::shared_ptr< RelProject >	prev_node,
		std::shared_ptr< RelProject >	new_node,
		std::unordered_map< size_t, RegisteredQueryHint > &	query_hints
	)

Definition at line 1928 of file RelAlgDagBuilder.cpp.

References CHECK.

Referenced by add_window_function_pre_project(), and separate_window_function_expressions().

                                                                 {
   auto delivered_hints = prev_node->getDeliveredHints();
   bool needs_propagate_hints = !delivered_hints->empty();
   if (needs_propagate_hints) {
     for (auto& kv : *delivered_hints) {
       new_node->addHint(kv.second);
     }
     auto prev_it = query_hints.find(prev_node->toHash());
     // query hint for the prev projection node should be registered
     CHECK(prev_it != query_hints.end());
     query_hints.emplace(new_node->toHash(), prev_it->second);
   }
 }

Here is the caller graph for this function:

std::vector<const Rex*> anonymous_namespace{RelAlgDagBuilder.cpp}::remapTargetPointers	(	std::vector< std::unique_ptr< const RexAgg >> const &	agg_exprs_new,
		std::vector< std::unique_ptr< const RexScalar >> const &	scalar_sources_new,
		std::vector< std::unique_ptr< const RexAgg >> const &	agg_exprs_old,
		std::vector< std::unique_ptr< const RexScalar >> const &	scalar_sources_old,
		std::vector< const Rex * > const &	target_exprs_old
	)

Definition at line 418 of file RelAlgDagBuilder.cpp.

References CHECK, and i.

                                                    {
   std::vector<const Rex*> target_exprs(target_exprs_old);
   std::unordered_map<const Rex*, const Rex*> old_to_new_target(target_exprs.size());
   for (size_t i = 0; i < agg_exprs_new.size(); ++i) {
     old_to_new_target.emplace(agg_exprs_old[i].get(), agg_exprs_new[i].get());
   }
   for (size_t i = 0; i < scalar_sources_new.size(); ++i) {
     old_to_new_target.emplace(scalar_sources_old[i].get(), scalar_sources_new[i].get());
   }
   for (auto& target : target_exprs) {
     auto target_it = old_to_new_target.find(target);
     CHECK(target_it != old_to_new_target.end());
     target = target_it->second;
   }
   return target_exprs;
 }

void anonymous_namespace{RelAlgDagBuilder.cpp}::separate_window_function_expressions	(	std::vector< std::shared_ptr< RelAlgNode >> &	nodes,
		std::unordered_map< size_t, RegisteredQueryHint > &	query_hints
	)

Detect the presence of window function operators nested inside expressions. Separate the window function operator from the expression, computing the expression as a subsequent step and replacing the window function operator with a RexInput. Also move all input nodes to the newly created project node. In pseudocode: for each rex in project list: detect window function expression if window function expression: copy window function expression replace window function expression in base expression w/ input add base expression to new project node after the current node replace base expression in current project node with the window function expression copy

Definition at line 1960 of file RelAlgDagBuilder.cpp.

References CHECK, CHECK_EQ, CHECK_LT, RelProject::getProjectAt(), i, anonymous_namespace{RelAlgDagBuilder.cpp}::anonymous_namespace{RelAlgDagBuilder.cpp}::is_window_function_operator(), propagate_hints_to_new_project(), and RexVisitorBase< T >::visit().

Referenced by RelAlgDagBuilder::build().

                                                                 {
   std::list<std::shared_ptr<RelAlgNode>> node_list(nodes.begin(), nodes.end());
 
   WindowFunctionDetectionVisitor visitor;
   for (auto node_itr = node_list.begin(); node_itr != node_list.end(); ++node_itr) {
     const auto node = *node_itr;
     auto window_func_project_node = std::dynamic_pointer_cast<RelProject>(node);
     if (!window_func_project_node) {
       continue;
     }
 
     // map scalar expression index in the project node to window function ptr
     std::unordered_map<size_t, const RexScalar*> embedded_window_function_expressions;
 
     // Iterate the target exprs of the project node and check for window function
     // expressions. If an embedded expression exists, save it in the
     // embedded_window_function_expressions map and split the expression into a window
     // function expression and a parent expression in a subsequent project node
     for (size_t i = 0; i < window_func_project_node->size(); i++) {
       const auto scalar_rex = window_func_project_node->getProjectAt(i);
       if (is_window_function_operator(scalar_rex)) {
         // top level window function exprs are fine
         continue;
       }
 
       if (const auto window_func_rex = visitor.visit(scalar_rex)) {
         const auto ret = embedded_window_function_expressions.insert(
             std::make_pair(i, window_func_rex));
         CHECK(ret.second);
       }
     }
 
     if (!embedded_window_function_expressions.empty()) {
       std::vector<std::unique_ptr<const RexScalar>> new_scalar_exprs;
 
       auto window_func_scalar_exprs =
           window_func_project_node->getExpressionsAndRelease();
       for (size_t rex_idx = 0; rex_idx < window_func_scalar_exprs.size(); ++rex_idx) {
         const auto embedded_window_func_expr_pair =
             embedded_window_function_expressions.find(rex_idx);
         if (embedded_window_func_expr_pair ==
             embedded_window_function_expressions.end()) {
           new_scalar_exprs.emplace_back(
               std::make_unique<const RexInput>(window_func_project_node.get(), rex_idx));
         } else {
           const auto window_func_rex_idx = embedded_window_func_expr_pair->first;
           CHECK_LT(window_func_rex_idx, window_func_scalar_exprs.size());
 
           const auto& window_func_rex = embedded_window_func_expr_pair->second;
 
           RexDeepCopyVisitor copier;
           auto window_func_rex_copy = copier.visit(window_func_rex);
 
           auto window_func_parent_expr =
               window_func_scalar_exprs[window_func_rex_idx].get();
 
           // Replace window func rex with an input rex
           auto window_func_result_input = std::make_unique<const RexInput>(
               window_func_project_node.get(), window_func_rex_idx);
           RexWindowFuncReplacementVisitor replacer(std::move(window_func_result_input));
           auto new_parent_rex = replacer.visit(window_func_parent_expr);
 
           // Put the parent expr in the new scalar exprs
           new_scalar_exprs.emplace_back(std::move(new_parent_rex));
 
           // Put the window func expr in cur scalar exprs
           window_func_scalar_exprs[window_func_rex_idx] = std::move(window_func_rex_copy);
         }
       }
 
       CHECK_EQ(window_func_scalar_exprs.size(), new_scalar_exprs.size());
       window_func_project_node->setExpressions(window_func_scalar_exprs);
 
       // Ensure any inputs from the node containing the expression (the "new" node)
       // exist on the window function project node, e.g. if we had a binary operation
       // involving an aggregate value or column not included in the top level
       // projection list.
       RexInputBackpropagationVisitor input_visitor(window_func_project_node.get());
       for (size_t i = 0; i < new_scalar_exprs.size(); i++) {
         if (dynamic_cast<const RexInput*>(new_scalar_exprs[i].get())) {
           // ignore top level inputs, these were copied directly from the previous
           // node
           continue;
         }
         new_scalar_exprs[i] = input_visitor.visit(new_scalar_exprs[i].get());
       }
 
       // Build the new project node and insert it into the list after the project node
       // containing the window function
       auto new_project =
           std::make_shared<RelProject>(new_scalar_exprs,
                                        window_func_project_node->getFields(),
                                        window_func_project_node);
       propagate_hints_to_new_project(window_func_project_node, new_project, query_hints);
       node_list.insert(std::next(node_itr), new_project);
 
       // Rebind all the following inputs
       for (auto rebind_itr = std::next(node_itr, 2); rebind_itr != node_list.end();
            rebind_itr++) {
         (*rebind_itr)->replaceInput(window_func_project_node, new_project);
       }
     }
   }
   nodes.assign(node_list.begin(), node_list.end());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::string> anonymous_namespace{RelAlgDagBuilder.cpp}::strings_from_json_array ( const rapidjson::Value & json_str_arr )

noexcept

Definition at line 1009 of file RelAlgDagBuilder.cpp.

References CHECK.

Referenced by details::RelAlgDispatcher::dispatchAggregate(), details::RelAlgDispatcher::dispatchProject(), getFieldNamesFromScanNode(), and details::RelAlgDispatcher::getRelAlgInputs().

                                                  {
   CHECK(json_str_arr.IsArray());
   std::vector<std::string> fields;
   for (auto json_str_arr_it = json_str_arr.Begin(); json_str_arr_it != json_str_arr.End();
        ++json_str_arr_it) {
     CHECK(json_str_arr_it->IsString());
     fields.emplace_back(json_str_arr_it->GetString());
   }
   return fields;
 }

Here is the caller graph for this function:

JoinType anonymous_namespace{RelAlgDagBuilder.cpp}::to_join_type ( const std::string & join_type_name )

Definition at line 1075 of file RelAlgDagBuilder.cpp.

References ANTI, INNER, LEFT, and SEMI.

Referenced by details::RelAlgDispatcher::dispatchJoin().

                                                        {
   if (join_type_name == "inner") {
     return JoinType::INNER;
   }
   if (join_type_name == "left") {
     return JoinType::LEFT;
   }
   if (join_type_name == "semi") {
     return JoinType::SEMI;
   }
   if (join_type_name == "anti") {
     return JoinType::ANTI;
   }
   throw QueryNotSupported("Join type (" + join_type_name + ") not supported");
 }

Here is the caller graph for this function:

Variable Documentation

const unsigned anonymous_namespace{RelAlgDagBuilder.cpp}::FIRST_RA_NODE_ID = 1

Definition at line 41 of file RelAlgDagBuilder.cpp.

Referenced by RelAlgNode::resetRelAlgFirstId().

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation