Inheritance diagram for anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor:

Collaboration diagram for anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor:

Public Member Functions
	RexWindowFuncReplacementVisitor (std::unordered_set< size_t > &collected_window_func_hash, std::vector< std::unique_ptr< const RexScalar >> &new_rex_input_for_window_func, std::unordered_map< size_t, size_t > &window_func_to_new_rex_input_idx_map, RelProject *new_project, std::unordered_map< size_t, std::unique_ptr< const RexInput >> &new_rex_input_from_child_node)

Public Member Functions inherited from RexVisitorBase< std::unique_ptr< const RexScalar > >
virtual std::unique_ptr< const RexScalar >	visit (const RexScalar *rex_scalar) const

Protected Member Functions
RetType	visitInput (const RexInput *rex_input) const final

RetType	visitOperator (const RexOperator *rex_operator) const final

RetType	visitCase (const RexCase *rex_case) const final

Protected Member Functions inherited from RexDeepCopyVisitor
RetType	visitInput (const RexInput *input) const override

RetType	visitLiteral (const RexLiteral *literal) const override

RetType	visitSubQuery (const RexSubQuery *subquery) const override

RetType	visitRef (const RexRef *ref) const override

RetType	visitOperator (const RexOperator *rex_operator) const override

RetType	visitWindowFunctionOperator (const RexWindowFunctionOperator *rex_window_function_operator) const

RetType	visitCase (const RexCase *rex_case) const override

Private Member Functions
std::optional< size_t >	is_collected_window_function (size_t rex_hash) const

std::unique_ptr< const RexScalar >	get_new_rex_input (size_t rex_idx) const

Private Attributes
std::unordered_set< size_t > &	collected_window_func_hash_

std::vector< std::unique_ptr < const RexScalar > > &	new_rex_input_for_window_func_

std::unordered_map< size_t, size_t > &	window_func_to_new_rex_input_idx_map_

RelProject *	new_project_

std::unordered_map< size_t, std::unique_ptr< const RexInput > > &	new_rex_input_from_child_node_

RexDeepCopyVisitor	copier_

Additional Inherited Members
Public Types inherited from RexDeepCopyVisitor
using	RowValues = std::vector< std::unique_ptr< const RexScalar >>

Static Public Member Functions inherited from RexDeepCopyVisitor
static std::vector< RowValues >	copy (std::vector< RowValues > const &rhs)

Protected Types inherited from RexDeepCopyVisitor
using	RetType = std::unique_ptr< const RexScalar >

Detailed Description

Definition at line 2182 of file RelAlgDag.cpp.

Constructor & Destructor Documentation

anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor::RexWindowFuncReplacementVisitor	(	std::unordered_set< size_t > &	collected_window_func_hash,
		std::vector< std::unique_ptr< const RexScalar >> &	new_rex_input_for_window_func,
		std::unordered_map< size_t, size_t > &	window_func_to_new_rex_input_idx_map,
		RelProject *	new_project,
		std::unordered_map< size_t, std::unique_ptr< const RexInput >> &	new_rex_input_from_child_node
	)

inline

Definition at line 2184 of file RelAlgDag.cpp.

References CHECK, CHECK_EQ, and CHECK_LT.

       : collected_window_func_hash_(collected_window_func_hash)
       , new_rex_input_for_window_func_(new_rex_input_for_window_func)
       , window_func_to_new_rex_input_idx_map_(window_func_to_new_rex_input_idx_map)
       , new_project_(new_project)
       , new_rex_input_from_child_node_(new_rex_input_from_child_node) {
     CHECK_EQ(collected_window_func_hash_.size(),
              window_func_to_new_rex_input_idx_map_.size());
     for (auto hash : collected_window_func_hash_) {
       auto rex_it = window_func_to_new_rex_input_idx_map_.find(hash);
       CHECK(rex_it != window_func_to_new_rex_input_idx_map_.end());
       CHECK_LT(rex_it->second, new_rex_input_for_window_func_.size());
     }
     CHECK(new_project_);
   }

Member Function Documentation

std::unique_ptr<const RexScalar> anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor::get_new_rex_input ( size_t rex_idx ) const

inlineprivate

Definition at line 2297 of file RelAlgDag.cpp.

References CHECK, CHECK_GE, and CHECK_LT.

                                                                          {
     CHECK_GE(rex_idx, 0UL);
     CHECK_LT(rex_idx, new_rex_input_for_window_func_.size());
     auto& new_rex_input = new_rex_input_for_window_func_.at(rex_idx);
     CHECK(new_rex_input);
     auto copied_rex_input = copier_.visit(new_rex_input.get());
     return copied_rex_input;
   }

std::optional<size_t> anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor::is_collected_window_function ( size_t rex_hash ) const

inlineprivate

Definition at line 2289 of file RelAlgDag.cpp.

                                                                           {
     auto rex_it = window_func_to_new_rex_input_idx_map_.find(rex_hash);
     if (rex_it != window_func_to_new_rex_input_idx_map_.end()) {
       return rex_it->second;
     }
     return std::nullopt;
   }

RetType anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor::visitCase ( const RexCase * rex_case ) const

inlinefinalprotectedvirtual

Implements RexVisitorBase< std::unique_ptr< const RexScalar > >.

Definition at line 2258 of file RelAlgDag.cpp.

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

                                                          {
     auto new_rex_idx = is_collected_window_function(rex_case->toHash());
     if (new_rex_idx) {
       return get_new_rex_input(*new_rex_idx);
     }
 
     std::vector<std::pair<RetType, RetType>> new_pair_list;
     for (size_t i = 0; i < rex_case->branchCount(); ++i) {
       auto when_operand = rex_case->getWhen(i);
       auto new_rex_idx_for_when_operand =
           is_collected_window_function(when_operand->toHash());
 
       auto then_operand = rex_case->getThen(i);
       auto new_rex_idx_for_then_operand =
           is_collected_window_function(then_operand->toHash());
 
       new_pair_list.emplace_back(
           new_rex_idx_for_when_operand ? get_new_rex_input(*new_rex_idx_for_when_operand)
                                        : visit(when_operand),
           new_rex_idx_for_then_operand ? get_new_rex_input(*new_rex_idx_for_then_operand)
                                        : visit(then_operand));
     }
     auto new_rex_idx_for_else_operand =
         is_collected_window_function(rex_case->getElse()->toHash());
     auto new_else = new_rex_idx_for_else_operand
                         ? get_new_rex_input(*new_rex_idx_for_else_operand)
                         : visit(rex_case->getElse());
     return std::make_unique<RexCase>(new_pair_list, new_else);
   }

Here is the call graph for this function:

RetType anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor::visitInput ( const RexInput * rex_input ) const

inlinefinalprotectedvirtual

Implements RexVisitorBase< std::unique_ptr< const RexScalar > >.

Definition at line 2207 of file RelAlgDag.cpp.

                                                             {
     if (rex_input->getSourceNode() != new_project_) {
       const auto cur_index = rex_input->getIndex();
       auto cur_source_node = rex_input->getSourceNode();
       std::string field_name = "";
       if (auto cur_project_node = dynamic_cast<const RelProject*>(cur_source_node)) {
         field_name = cur_project_node->getFieldName(cur_index);
       }
       auto rex_input_hash = rex_input->toHash();
       auto rex_input_it = new_rex_input_from_child_node_.find(rex_input_hash);
       if (rex_input_it == new_rex_input_from_child_node_.end()) {
         auto new_rex_input =
             std::make_unique<RexInput>(new_project_, new_project_->size());
         new_project_->appendInput(field_name, rex_input->deepCopy());
         new_rex_input_from_child_node_.emplace(rex_input_hash, new_rex_input->deepCopy());
         return new_rex_input;
       } else {
         return rex_input_it->second->deepCopy();
       }
     } else {
       return rex_input->deepCopy();
     }
   }

RetType anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor::visitOperator ( const RexOperator * rex_operator ) const

inlinefinalprotectedvirtual

Implements RexVisitorBase< std::unique_ptr< const RexScalar > >.

Definition at line 2231 of file RelAlgDag.cpp.

                                                                      {
     auto new_rex_idx = is_collected_window_function(rex_operator->toHash());
     if (new_rex_idx) {
       return get_new_rex_input(*new_rex_idx);
     }
 
     const auto rex_window_function_operator =
         dynamic_cast<const RexWindowFunctionOperator*>(rex_operator);
     if (rex_window_function_operator) {
       // Deep copy the embedded window function operator
       return visitWindowFunctionOperator(rex_window_function_operator);
     }
 
     const size_t operand_count = rex_operator->size();
     std::vector<RetType> new_opnds;
     for (size_t i = 0; i < operand_count; ++i) {
       const auto operand = rex_operator->getOperand(i);
       auto new_rex_idx_for_operand = is_collected_window_function(operand->toHash());
       if (new_rex_idx_for_operand) {
         new_opnds.push_back(get_new_rex_input(*new_rex_idx_for_operand));
       } else {
         new_opnds.emplace_back(visit(rex_operator->getOperand(i)));
       }
     }
     return rex_operator->getDisambiguated(new_opnds);
   }

Member Data Documentation

std::unordered_set<size_t>& anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor::collected_window_func_hash_

private

Definition at line 2306 of file RelAlgDag.cpp.

RexDeepCopyVisitor anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor::copier_

private

Definition at line 2314 of file RelAlgDag.cpp.

RelProject* anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor::new_project_

private

Definition at line 2311 of file RelAlgDag.cpp.

std::vector<std::unique_ptr<const RexScalar> >& anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor::new_rex_input_for_window_func_

private

Definition at line 2308 of file RelAlgDag.cpp.

std::unordered_map<size_t, std::unique_ptr<const RexInput> >& anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor::new_rex_input_from_child_node_

private

Definition at line 2313 of file RelAlgDag.cpp.

std::unordered_map<size_t, size_t>& anonymous_namespace{RelAlgDag.cpp}::RexWindowFuncReplacementVisitor::window_func_to_new_rex_input_idx_map_

private

Definition at line 2310 of file RelAlgDag.cpp.

The documentation for this class was generated from the following file:

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/RelAlgDag.cpp

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation