RelRexDagVisitor Class Reference

#include <RelRexDagVisitor.h>

Inheritance diagram for RelRexDagVisitor:

Public Member Functions
virtual	~RelRexDagVisitor ()=default
void	visit (RelAlgNode const *)
virtual void	visit (RexScalar const *)

Protected Member Functions
virtual void	visit (RelAggregate const *)
virtual void	visit (RelCompound const *)
virtual void	visit (RelFilter const *)
virtual void	visit (RelJoin const *)
virtual void	visit (RelLeftDeepInnerJoin const *)
virtual void	visit (RelLogicalUnion const *)
virtual void	visit (RelLogicalValues const *)
virtual void	visit (RelModify const *)
virtual void	visit (RelProject const *)
virtual void	visit (RelScan const *)
virtual void	visit (RelSort const *)
virtual void	visit (RelTableFunction const *)
virtual void	visit (RexAbstractInput const *)
virtual void	visit (RexCase const *)
virtual void	visit (RexFunctionOperator const *)
virtual void	visit (RexInput const *)
virtual void	visit (RexLiteral const *)
virtual void	visit (RexOperator const *)
virtual void	visit (RexRef const *)
virtual void	visit (RexSubQuery const *)
virtual void	visit (RexWindowFunctionOperator const *)

Private Types
template<typename T , size_t N>
using	Handlers = std::array< TypeHandler< RelRexDagVisitor, T >, N >

Private Member Functions
template<typename T , typename U >
void	cast (T const *node)

Static Private Member Functions
template<typename T , typename... Ts>
static Handlers< T, sizeof...(Ts)>	make_handlers ()

Detailed Description

Definition at line 34 of file RelRexDagVisitor.h.

Member Typedef Documentation

template<typename T , size_t N>

using RelRexDagVisitor::Handlers = std::array<TypeHandler<RelRexDagVisitor, T>, N>

private

Definition at line 71 of file RelRexDagVisitor.h.

Constructor & Destructor Documentation

virtual RelRexDagVisitor::~RelRexDagVisitor ( )

virtualdefault

Member Function Documentation

template<typename T , typename U >

void RelRexDagVisitor::cast ( T const *  node )

inlineprivate

Definition at line 66 of file RelRexDagVisitor.h.

References visit().

                           {
    visit(dynamic_cast<U const*>(node));
  }

Here is the call graph for this function:

template<typename T , typename... Ts>

RelRexDagVisitor::Handlers< T, sizeof...(Ts)> RelRexDagVisitor::make_handlers ( )

staticprivate

Definition at line 32 of file RelRexDagVisitor.cpp.

References gpu_enabled::sort(), and omnisci.dtypes::T.

Referenced by visit().

                                                                           {
  RelRexDagVisitor::Handlers<T, sizeof...(Ts)> handlers{
      {{std::type_index(typeid(Ts)), &RelRexDagVisitor::cast<T, Ts>}...}};
  std::sort(handlers.begin(), handlers.end());
  return handlers;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void RelRexDagVisitor::visit

(

RelAlgNode const *

rel_alg_node

)

Definition at line 41 of file RelRexDagVisitor.cpp.

References logger::FATAL, RelAlgNode::getInput(), i, RelAlgNode::inputCount(), LOG, gpu_enabled::lower_bound(), make_handlers(), and RelAlgNode::toString().

Referenced by cast(), RexSubQueryIdCollector::visit(), and visit().

                                                           {
  // Array that pairs std::type_index(typeid(*rel_alg_node)) -> method pointer.
  static auto const handlers = make_handlers<RelAlgNode,
                                             RelAggregate,
                                             RelCompound,
                                             RelFilter,
                                             RelJoin,
                                             RelLeftDeepInnerJoin,
                                             RelLogicalUnion,
                                             RelLogicalValues,
                                             RelModify,
                                             RelProject,
                                             RelScan,
                                             RelSort,
                                             RelTableFunction>();
  static_assert(std::is_trivially_destructible_v<decltype(handlers)>);
  // Will throw std::bad_typeid if rel_alg_node == nullptr.
  auto const& type_index = std::type_index(typeid(*rel_alg_node));
  auto const itr = std::lower_bound(handlers.cbegin(), handlers.cend(), type_index);
  if (itr != handlers.cend() && itr->type_index == type_index) {
    (this->*itr->handler)(rel_alg_node);
  } else {
    LOG(FATAL) << "Unhandled RelAlgNode type: " << rel_alg_node->toString();
  }
  for (size_t i = 0; i < rel_alg_node->inputCount(); ++i) {
    visit(rel_alg_node->getInput(i));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void RelRexDagVisitor::visit ( RexScalar const *  rex_scalar )

virtual

Definition at line 115 of file RelRexDagVisitor.cpp.

References logger::FATAL, LOG, gpu_enabled::lower_bound(), make_handlers(), and Rex::toString().

                                                        {
  // Array that pairs std::type_index(typeid(*rex_scalar)) -> method pointer.
  static auto const handlers = make_handlers<RexScalar,
                                             RexAbstractInput,
                                             RexCase,
                                             RexFunctionOperator,
                                             RexInput,
                                             RexLiteral,
                                             RexOperator,
                                             RexRef,
                                             RexSubQuery,
                                             RexWindowFunctionOperator>();
  static_assert(std::is_trivially_destructible_v<decltype(handlers)>);
  // Will throw std::bad_typeid if rex_scalar == nullptr.
  auto const& type_index = std::type_index(typeid(*rex_scalar));
  auto const itr = std::lower_bound(handlers.cbegin(), handlers.cend(), type_index);
  if (itr != handlers.cend() && itr->type_index == type_index) {
    (this->*itr->handler)(rex_scalar);
  } else {
    LOG(FATAL) << "Unhandled RexScalar type: " << rex_scalar->toString();
  }
}

Here is the call graph for this function:

virtual void RelRexDagVisitor::visit ( RelAggregate const *  )

inlineprotectedvirtual

Definition at line 41 of file RelRexDagVisitor.h.

{}

void RelRexDagVisitor::visit ( RelCompound const *  rel_compound )

protectedvirtual

Definition at line 70 of file RelRexDagVisitor.cpp.

References RelCompound::getFilterExpr(), and visit().

                                                            {
  if (rel_compound->getFilterExpr()) {
    visit(rel_compound->getFilterExpr());
  }
}

Here is the call graph for this function:

void RelRexDagVisitor::visit ( RelFilter const *  rel_filter )

protectedvirtual

Definition at line 76 of file RelRexDagVisitor.cpp.

References RelFilter::getCondition(), and visit().

                                                        {
  visit(rel_filter->getCondition());
}

Here is the call graph for this function:

void RelRexDagVisitor::visit ( RelJoin const *  rel_join )

protectedvirtual

Definition at line 80 of file RelRexDagVisitor.cpp.

References RelJoin::getCondition(), and visit().

                                                    {
  visit(rel_join->getCondition());
}

Here is the call graph for this function:

void RelRexDagVisitor::visit ( RelLeftDeepInnerJoin const *  rel_left_deep_inner_join )

protectedvirtual

Definition at line 84 of file RelRexDagVisitor.cpp.

References RelLeftDeepInnerJoin::getInnerCondition(), RelLeftDeepInnerJoin::getOuterCondition(), RelAlgNode::inputCount(), and visit().

                                                                                 {
  visit(rel_left_deep_inner_join->getInnerCondition());
  for (size_t level = 1; level < rel_left_deep_inner_join->inputCount(); ++level) {
    if (auto* outer_condition = rel_left_deep_inner_join->getOuterCondition(level)) {
      visit(outer_condition);
    }
  }
}

Here is the call graph for this function:

virtual void RelRexDagVisitor::visit ( RelLogicalUnion const *  )

inlineprotectedvirtual

Definition at line 46 of file RelRexDagVisitor.h.

{}

void RelRexDagVisitor::visit ( RelLogicalValues const *  rel_logical_values )

protectedvirtual

Definition at line 93 of file RelRexDagVisitor.cpp.

References RelLogicalValues::getNumRows(), RelLogicalValues::getRowsSize(), RelLogicalValues::getValueAt(), and visit().

                                                                       {
  for (size_t row_idx = 0; row_idx < rel_logical_values->getNumRows(); ++row_idx) {
    for (size_t col_idx = 0; col_idx < rel_logical_values->getRowsSize(); ++col_idx) {
      visit(rel_logical_values->getValueAt(row_idx, col_idx));
    }
  }
}

Here is the call graph for this function:

virtual void RelRexDagVisitor::visit ( RelModify const *  )

inlineprotectedvirtual

Definition at line 48 of file RelRexDagVisitor.h.

{}

void RelRexDagVisitor::visit ( RelProject const *  rel_projection )

protectedvirtual

Definition at line 101 of file RelRexDagVisitor.cpp.

References RelProject::getProjectAt(), i, RelProject::size(), and visit().

                                                             {
  for (size_t i = 0; i < rel_projection->size(); ++i) {
    visit(rel_projection->getProjectAt(i));
  }
}

Here is the call graph for this function:

virtual void RelRexDagVisitor::visit ( RelScan const *  )

inlineprotectedvirtual

Definition at line 50 of file RelRexDagVisitor.h.

{}

virtual void RelRexDagVisitor::visit ( RelSort const *  )

inlineprotectedvirtual

Definition at line 51 of file RelRexDagVisitor.h.

{}

void RelRexDagVisitor::visit ( RelTableFunction const *  rel_table_function )

protectedvirtual

Definition at line 107 of file RelRexDagVisitor.cpp.

References RelTableFunction::getTableFuncInputAt(), RelTableFunction::getTableFuncInputsSize(), i, and visit().

                                                                       {
  for (size_t i = 0; i < rel_table_function->getTableFuncInputsSize(); ++i) {
    visit(rel_table_function->getTableFuncInputAt(i));
  }
}

Here is the call graph for this function:

virtual void RelRexDagVisitor::visit ( RexAbstractInput const *  )

inlineprotectedvirtual

Definition at line 54 of file RelRexDagVisitor.h.

{}

void RelRexDagVisitor::visit ( RexCase const *  rex_case )

protectedvirtual

Definition at line 148 of file RelRexDagVisitor.cpp.

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

                                                    {
  for (size_t i = 0; i < rex_case->branchCount(); ++i) {
    visit(rex_case->getWhen(i));
    visit(rex_case->getThen(i));
  }
  if (rex_case->getElse()) {
    visit(rex_case->getElse());
  }
}

Here is the call graph for this function:

void RelRexDagVisitor::visit ( RexFunctionOperator const *  rex_function_operator )

protectedvirtual

Definition at line 158 of file RelRexDagVisitor.cpp.

References RexOperator::getOperand(), i, RexOperator::size(), and visit().

                                                                             {
  for (size_t i = 0; i < rex_function_operator->size(); ++i) {
    visit(rex_function_operator->getOperand(i));
  }
}

Here is the call graph for this function:

virtual void RelRexDagVisitor::visit ( RexInput const *  )

inlineprotectedvirtual

Definition at line 57 of file RelRexDagVisitor.h.

{}  // Don't visit SourceNode

virtual void RelRexDagVisitor::visit ( RexLiteral const *  )

inlineprotectedvirtual

Definition at line 58 of file RelRexDagVisitor.h.

{}

void RelRexDagVisitor::visit ( RexOperator const *  rex_operator )

protectedvirtual

Definition at line 164 of file RelRexDagVisitor.cpp.

References RexOperator::getOperand(), i, RexOperator::size(), and visit().

                                                            {
  for (size_t i = 0; i < rex_operator->size(); ++i) {
    visit(rex_operator->getOperand(i));
  }
}

Here is the call graph for this function:

virtual void RelRexDagVisitor::visit ( RexRef const *  )

inlineprotectedvirtual

Definition at line 60 of file RelRexDagVisitor.h.

{}

void RelRexDagVisitor::visit ( RexSubQuery const *  rex_sub_query )

protectedvirtual

Reimplemented in RexSubQueryIdCollector.

Definition at line 170 of file RelRexDagVisitor.cpp.

References visit().

                                                             {
  visit(rex_sub_query->getRelAlg());
}

Here is the call graph for this function:

void RelRexDagVisitor::visit ( RexWindowFunctionOperator const *  rex_window_function_operator )

protectedvirtual

Definition at line 138 of file RelRexDagVisitor.cpp.

References RexWindowFunctionOperator::getOrderKeys(), RexWindowFunctionOperator::getPartitionKeys(), and visit().

                                                                   {
  for (const auto& partition_key : rex_window_function_operator->getPartitionKeys()) {
    visit(partition_key.get());
  }
  for (const auto& order_key : rex_window_function_operator->getOrderKeys()) {
    visit(order_key.get());
  }
}

Here is the call graph for this function:

---

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

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/Visitors/RelRexDagVisitor.h
• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/Visitors/RelRexDagVisitor.cpp