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) noexcept

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

void	separate_window_function_expressions (std::vector< std::shared_ptr< RelAlgNode >> &nodes)

void	add_window_function_pre_project (std::vector< std::shared_ptr< RelAlgNode >> &nodes)

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 1988 of file RelAlgDagBuilder.cpp.

Function Documentation

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

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). 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 2012 of file RelAlgDagBuilder.cpp.

References CHECK(), CHECK_EQ, and RexVisitorBase< T >::visit().

Referenced by RelAlgDagBuilder::build().

                                                                                   {
   std::list<std::shared_ptr<RelAlgNode>> node_list(nodes.begin(), nodes.end());
 
   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;
     }
     if (!window_func_project_node->hasWindowFunctionExpr()) {
       // the first projection node in the query plan does not have a window function
       // expression -- this step is not requierd.
       return;
     }
 
     const auto prev_node_itr = std::prev(node_itr);
     const auto prev_node = *prev_node_itr;
     CHECK(prev_node);
 
     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);
     node_list.insert(node_itr, new_project);
     window_func_project_node->replaceInput(
         prev_node, new_project, old_index_to_new_index);
 
     break;
   }
 
   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 1159 of file RelAlgDagBuilder.cpp.

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

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) {
       bind_table_func_to_input(table_func_node.get(),
                                get_node_output(table_func_node->getInput(0)));
     }
   }
 }

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 1130 of file RelAlgDagBuilder.cpp.

References CHECK_EQ, and disambiguate_rex().

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 1144 of file RelAlgDagBuilder.cpp.

References CHECK_EQ, and disambiguate_rex().

Referenced by bind_inputs().

                                                                   {
   CHECK_EQ(size_t(1), table_func_node->inputCount());
   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 2082 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
	)

Definition at line 1593 of file RelAlgDagBuilder.cpp.

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

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;
     decltype(crt_pattern)().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 (std::dynamic_pointer_cast<const RelProject>(ra_node)) {
           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)) {
           if (project_node->hasWindowFunctionExpr()) {
             reset_state();
             break;
           }
           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);
           }
           reset_state();
         }
         break;
       }
       case CoalesceState::Aggregate: {
         if (auto project_node = std::dynamic_pointer_cast<const RelProject>(ra_node)) {
           // 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);
         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);
     }
     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 398 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 408 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
	)

noexcept

Definition at line 1292 of file RelAlgDagBuilder.cpp.

References bind_project_to_input(), CHECK(), CHECK_EQ, CHECK_GE, CHECK_LE, CHECK_LT, get_node_output(), RelProject::getFields(), 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;
 
   for (const auto node_idx : pattern) {
     const auto ra_node = nodes[node_idx];
     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));
   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 1088 of file RelAlgDagBuilder.cpp.

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

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 1053 of file RelAlgDagBuilder.cpp.

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

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 1109 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 510 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 call graph for this function:

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 2068 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->getTypeScale());
   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 2097 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 2087 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 1191 of file RelAlgDagBuilder.cpp.

References QueryHint::cpu_mode, and VLOG.

Referenced by RelAlgDagBuilder::build().

                                                              {
   QueryHint query_hints;
   for (auto node : nodes) {
     const auto agg_node = std::dynamic_pointer_cast<RelAggregate>(node);
     if (agg_node) {
       if (agg_node->hasHintEnabled("cpu_mode")) {
         query_hints.cpu_mode = true;
       }
     }
     const auto project_node = std::dynamic_pointer_cast<RelProject>(node);
     if (project_node) {
       if (project_node->hasHintEnabled("cpu_mode")) {
         query_hints.cpu_mode = true;
       }
     }
     const auto scan_node = std::dynamic_pointer_cast<RelScan>(node);
     if (scan_node) {
       if (scan_node->hasHintEnabled("cpu_mode")) {
         query_hints.cpu_mode = true;
       }
     }
     const auto join_node = std::dynamic_pointer_cast<RelJoin>(node);
     if (join_node) {
       if (join_node->hasHintEnabled("cpu_mode")) {
         query_hints.cpu_mode = true;
       }
     }
     const auto compound_node = std::dynamic_pointer_cast<RelCompound>(node);
     if (compound_node) {
       if (compound_node->hasHintEnabled("cpu_mode")) {
         query_hints.cpu_mode = true;
       }
     }
   }
   if (query_hints.cpu_mode) {
     VLOG(1) << "A user forces to run the query on the CPU execution mode";
   }
   dag_builder->registerQueryHints(query_hints);
 }

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 992 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 call graph for this function:

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 252 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 668 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 1232 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.

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 663 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 679 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 1005 of file RelAlgDagBuilder.cpp.

References field(), indices_from_json_array(), json_bool(), json_str(), kAPPROX_COUNT_DISTINCT, parse_type(), and to_agg_kind().

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

                                                                              {
   const auto agg = to_agg_kind(json_str(field(expr, "agg")));
   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)) {
     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 958 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 779 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 685 of file RelAlgDagBuilder.cpp.

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

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 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));
       }
       CHECK(literal.IsInt64());
       return std::unique_ptr<RexLiteral>(
           new RexLiteral(static_cast<double>(json_i64(literal)),
                          type,
                          target_type,
                          scale,
                          precision,
                          type_scale,
                          type_precision));
     }
     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 859 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 912 of file RelAlgDagBuilder.cpp.

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

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 1016 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 853 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 898 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 760 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 878 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 790 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 865 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 842 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:

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 419 of file RelAlgDagBuilder.cpp.

References CHECK().

                                                    {
   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;
 }

Here is the call graph for this function:

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

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 1882 of file RelAlgDagBuilder.cpp.

References CHECK(), CHECK_EQ, CHECK_LT, RelProject::getProjectAt(), anonymous_namespace{RelAlgDagBuilder.cpp}::anonymous_namespace{RelAlgDagBuilder.cpp}::is_window_function_operator(), 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 wiondow 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);
       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 980 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 call graph for this function:

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 1041 of file RelAlgDagBuilder.cpp.

References INNER, and LEFT.

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

                                                        {
   if (join_type_name == "inner") {
     return JoinType::INNER;
   }
   if (join_type_name == "left") {
     return JoinType::LEFT;
   }
   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