Namespaces
	anonymous_namespace{RelAlgDagBuilder.cpp}

Classes
class	RexRebindInputsVisitor

class	RANodeIterator

class	WindowFunctionDetectionVisitor

class	RexWindowFuncReplacementVisitor

class	RexInputBackpropagationVisitor

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::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::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::string	json_node_to_string (const rapidjson::Value &node) 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	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)

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

Function Documentation

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

noexcept

Definition at line 979 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 950 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 964 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 1790 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 1381 of file RelAlgDagBuilder.cpp.

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

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_has_window_function_input(project_node.get())) {
             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:

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

noexcept

Definition at line 1071 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 908 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 873 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 929 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 420 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 1776 of file RelAlgDagBuilder.cpp.

References CHECK_EQ, field(), kDECIMAL, and anonymous_namespace{CalciteAdapter.cpp}::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 1805 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 1795 of file RelAlgDagBuilder.cpp.

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

Referenced by anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::CalciteAdapter(), 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:

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

noexcept

Definition at line 805 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 209 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));
   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 818 of file RelAlgDagBuilder.cpp.

Referenced by parse_scalar_expr().

                                                                    {
   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 1011 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 87 of file RelAlgDagBuilder.cpp.

Referenced by get_node_output().

                                                                       {
   std::vector<RexInput> outputs;
   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 490 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 499 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 825 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 771 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 592 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 505 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.

                                                                     {
   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"));
   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:

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

Definition at line 672 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 725 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 836 of file RelAlgDagBuilder.cpp.

References CHECK(), field(), json_node_to_string(), json_str(), parse_abstract_input(), parse_case(), anonymous_namespace{CalciteAdapter.cpp}::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 666 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 711 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 577 of file RelAlgDagBuilder.cpp.

References CHECK(), field(), json_bool(), json_i64(), json_str(), SQLTypeInfoCore< TYPE_FACET_PACK >::set_precision(), SQLTypeInfoCore< TYPE_FACET_PACK >::set_scale(), to_sql_type(), and run_benchmark_import::type.

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

                                                        {
   CHECK(type_obj.IsObject() && type_obj.MemberCount() >= 2);
   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 691 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 603 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 678 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 655 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}::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 1670 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 793 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 861 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 38 of file RelAlgDagBuilder.cpp.

Referenced by RelAlgNode::resetRelAlgFirstId().

Namespaces

Classes

Functions

Variables

Function Documentation

Variable Documentation