Classes
class	RexInputReplacementVisitor

class	CoalesceSecondaryProjectVisitor

Functions
std::vector< const Rex * >	reproject_targets (const RelProject simple_project, const std::vector< const Rex > &target_exprs) noexcept

bool	input_can_be_coalesced (const RelAlgNode *parent_node, const size_t index, const bool first_rex_is_input)

bool	is_window_function_sum (const RexScalar *rex)

bool	is_window_function_avg (const RexScalar *rex)

bool	is_window_function_operator (const RexScalar *rex)

void	create_rex_input_for_new_project_node (RelAlgNode const *node, std::vector< std::unique_ptr< const RexScalar >> &scalar_exprs, std::vector< std::string > &fields)

bool	find_generic_expr_in_window_func (RexWindowFunctionOperator const *window_expr, bool &has_generic_expr_in_window_func)

std::pair< bool, bool >	need_pushdown_generic_expr (RelProject const *window_func_project_node)

Function Documentation

void anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::create_rex_input_for_new_project_node	(	RelAlgNode const *	node,
		std::vector< std::unique_ptr< const RexScalar >> &	scalar_exprs,
		std::vector< std::string > &	fields
	)

Definition at line 2118 of file RelAlgDag.cpp.

References RelAlgNode::size().

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

                                   {
   for (size_t i = 0; i < node->size(); i++) {
     auto new_rex_input = std::make_unique<RexInput>(node, i);
     scalar_exprs.emplace_back(std::move(new_rex_input));
     fields.emplace_back("");
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::find_generic_expr_in_window_func	(	RexWindowFunctionOperator const *	window_expr,
		bool &	has_generic_expr_in_window_func
	)

Definition at line 2588 of file RelAlgDag.cpp.

References RexOperator::getOperand(), RexWindowFunctionOperator::getOrderKeys(), RexWindowFunctionOperator::getPartitionKeys(), and RexOperator::size().

Referenced by need_pushdown_generic_expr().

                                                                              {
   for (auto const& partition_key : window_expr->getPartitionKeys()) {
     auto partition_input = dynamic_cast<RexInput const*>(partition_key.get());
     if (!partition_input) {
       return true;
     }
   }
   for (auto const& order_key : window_expr->getOrderKeys()) {
     auto order_input = dynamic_cast<RexInput const*>(order_key.get());
     if (!order_input) {
       return true;
     }
   }
   for (size_t k = 0; k < window_expr->size(); k++) {
     if (!shared::dynamic_castable_to_any<RexInput, RexLiteral>(
             window_expr->getOperand(k))) {
       has_generic_expr_in_window_func = true;
       return true;
     }
   }
   return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::input_can_be_coalesced	(	const RelAlgNode *	parent_node,
		const size_t	index,
		const bool	first_rex_is_input
	)

Definition at line 1922 of file RelAlgDag.cpp.

Referenced by anonymous_namespace{RelAlgDag.cpp}::coalesce_nodes(), and anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::CoalesceSecondaryProjectVisitor::visitInput().

                                                            {
   if (auto agg_node = dynamic_cast<const RelAggregate*>(parent_node)) {
     if (index == 0 && agg_node->getGroupByCount() > 0) {
       return true;
     } else {
       // Is an aggregated target, only allow the project to be elided if the aggregate
       // target is simply passed through (i.e. if the top level expression attached to
       // the project node is a RexInput expression)
       return first_rex_is_input;
     }
   }
   return first_rex_is_input;
 }

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::is_window_function_avg ( const RexScalar * rex )

Definition at line 1981 of file RelAlgDag.cpp.

References CHECK_EQ, COUNT, RexOperator::getOperand(), RexOperator::getOperator(), is_window_function_sum(), kDIVIDE, and RexOperator::size().

Referenced by is_window_function_operator().

                                                   {
   const RexOperator* divide_operator = dynamic_cast<const RexOperator*>(rex);
   if (divide_operator && divide_operator->getOperator() == kDIVIDE) {
     CHECK_EQ(divide_operator->size(), size_t(2));
     const auto case_operator =
         dynamic_cast<const RexCase*>(divide_operator->getOperand(0));
     const auto second_window =
         dynamic_cast<const RexWindowFunctionOperator*>(divide_operator->getOperand(1));
     if (case_operator && second_window &&
         second_window->getKind() == SqlWindowFunctionKind::COUNT) {
       if (is_window_function_sum(case_operator)) {
         return true;
       }
     }
   }
   return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::is_window_function_operator ( const RexScalar * rex )

Definition at line 2001 of file RelAlgDag.cpp.

References is_window_function_avg(), and is_window_function_sum().

Referenced by RelProject::hasWindowFunctionExpr(), anonymous_namespace{RelAlgDag.cpp}::separate_window_function_expressions(), anonymous_namespace{RelAlgDag.cpp}::WindowFunctionCollector::visitCase(), and anonymous_namespace{RelAlgDag.cpp}::WindowFunctionCollector::visitOperator().

                                                        {
   return dynamic_cast<const RexWindowFunctionOperator*>(rex) ||
          is_window_function_sum(rex) || is_window_function_avg(rex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::is_window_function_sum ( const RexScalar * rex )

Definition at line 1967 of file RelAlgDag.cpp.

References SUM_INTERNAL.

Referenced by is_window_function_avg(), and is_window_function_operator().

                                                   {
   const auto case_operator = dynamic_cast<const RexCase*>(rex);
   if (case_operator && case_operator->branchCount() == 1) {
     const auto then_window =
         dynamic_cast<const RexWindowFunctionOperator*>(case_operator->getThen(0));
     if (then_window && then_window->getKind() == SqlWindowFunctionKind::SUM_INTERNAL) {
       return true;
     }
   }
   return false;
 }

Here is the caller graph for this function:

std::pair<bool, bool> anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::need_pushdown_generic_expr ( RelProject const * window_func_project_node )

Definition at line 2612 of file RelAlgDag.cpp.

References CHECK, find_generic_expr_in_window_func(), RelProject::getProjectAt(), run_benchmark_import::res, and RelProject::size().

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

                                                 {
   bool has_generic_expr_in_window_func = false;
   bool res = false;
   for (size_t i = 0; i < window_func_project_node->size(); ++i) {
     auto const projected_target = window_func_project_node->getProjectAt(i);
     if (auto const* window_expr =
             dynamic_cast<RexWindowFunctionOperator const*>(projected_target)) {
       res =
           find_generic_expr_in_window_func(window_expr, has_generic_expr_in_window_func);
     } else if (auto const* case_expr = dynamic_cast<RexCase const*>(projected_target)) {
       std::unordered_map<size_t, const RexScalar*> collected_window_func;
       WindowFunctionCollector collector(collected_window_func, true);
       collector.visit(case_expr);
       for (auto const& kv : collected_window_func) {
         auto const* candidate_window_expr =
             dynamic_cast<RexWindowFunctionOperator const*>(kv.second);
         CHECK(candidate_window_expr);
         res = find_generic_expr_in_window_func(candidate_window_expr,
                                                has_generic_expr_in_window_func);
       }
     }
   }
   return std::make_pair(has_generic_expr_in_window_func, res);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<const Rex*> anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::reproject_targets	(	const RelProject *	simple_project,
		const std::vector< const Rex * > &	target_exprs
	)

noexcept

Definition at line 1639 of file RelAlgDag.cpp.

References CHECK, CHECK_LT, and run_benchmark_import::result.

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

                                                         {
   std::vector<const Rex*> result;
   for (size_t i = 0; i < simple_project->size(); ++i) {
     const auto input_rex = dynamic_cast<const RexInput*>(simple_project->getProjectAt(i));
     CHECK(input_rex);
     CHECK_LT(static_cast<size_t>(input_rex->getIndex()), target_exprs.size());
     result.push_back(target_exprs[input_rex->getIndex()]);
   }
   return result;
 }

Here is the caller graph for this function:

Classes

Functions

Function Documentation