anonymous_namespace{RelLeftDeepInnerJoin.cpp} Namespace Reference

Classes
class	RebindRexInputsFromLeftDeepJoin

Functions
void	collect_left_deep_join_inputs (std::deque< std::shared_ptr< const RelAlgNode >> &inputs, std::vector< std::shared_ptr< const RelJoin >> &original_joins, const std::shared_ptr< const RelJoin > &join)
std::pair< std::shared_ptr < RelLeftDeepInnerJoin > , std::shared_ptr< const RelAlgNode > >	create_left_deep_join (const std::shared_ptr< RelAlgNode > &left_deep_join_root)

Function Documentation

void anonymous_namespace{RelLeftDeepInnerJoin.cpp}::collect_left_deep_join_inputs	(	std::deque< std::shared_ptr< const RelAlgNode >> &	inputs,
		std::vector< std::shared_ptr< const RelJoin >> &	original_joins,
		const std::shared_ptr< const RelJoin > &	join
	)

Definition at line 181 of file RelLeftDeepInnerJoin.cpp.

References CHECK_EQ.

Referenced by create_left_deep_join().

                                              {
  original_joins.push_back(join);
  CHECK_EQ(size_t(2), join->inputCount());
  const auto left_input_join =
      std::dynamic_pointer_cast<const RelJoin>(join->getAndOwnInput(0));
  if (left_input_join) {
    inputs.push_front(join->getAndOwnInput(1));
    collect_left_deep_join_inputs(inputs, original_joins, left_input_join);
  } else {
    inputs.push_front(join->getAndOwnInput(1));
    inputs.push_front(join->getAndOwnInput(0));
  }
}

Here is the caller graph for this function:

std::pair<std::shared_ptr<RelLeftDeepInnerJoin>, std::shared_ptr<const RelAlgNode> > anonymous_namespace{RelLeftDeepInnerJoin.cpp}::create_left_deep_join

(

const std::shared_ptr< RelAlgNode > &

left_deep_join_root

)

Definition at line 199 of file RelLeftDeepInnerJoin.cpp.

References CHECK, collect_left_deep_join_inputs(), get_left_deep_join_root(), and join().

Referenced by create_left_deep_join(), and RelAlgDagBuilder::optimizeDag().

                                                                            {
  const auto old_root = get_left_deep_join_root(left_deep_join_root);
  if (!old_root) {
    return {nullptr, nullptr};
  }
  std::deque<std::shared_ptr<const RelAlgNode>> inputs_deque;
  const auto left_deep_join_filter =
      std::dynamic_pointer_cast<RelFilter>(left_deep_join_root);
  const auto join =
      std::dynamic_pointer_cast<const RelJoin>(left_deep_join_root->getAndOwnInput(0));
  CHECK(join);
  std::vector<std::shared_ptr<const RelJoin>> original_joins;
  collect_left_deep_join_inputs(inputs_deque, original_joins, join);
  std::vector<std::shared_ptr<const RelAlgNode>> inputs(inputs_deque.begin(),
                                                        inputs_deque.end());
  return {std::make_shared<RelLeftDeepInnerJoin>(
              left_deep_join_filter, inputs, original_joins),
          old_root};
}

Here is the call graph for this function:

Here is the caller graph for this function: