RexDeepCopyVisitor Class Reference

#include <RexVisitor.h>

Inheritance diagram for RexDeepCopyVisitor:

Collaboration diagram for RexDeepCopyVisitor:

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

Protected Member Functions
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
RetType	defaultResult () const override

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

Detailed Description

Definition at line 137 of file RexVisitor.h.

Member Typedef Documentation

RetType

using RexDeepCopyVisitor::RetType = std::unique_ptr<const RexScalar>

protected

Definition at line 139 of file RexVisitor.h.

Member Function Documentation

defaultResult()

RetType RexDeepCopyVisitor::defaultResult ( ) const

inlineoverrideprivatevirtual

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

Definition at line 204 of file RexVisitor.h.

{ return nullptr; }

visitCase()

RetType RexDeepCopyVisitor::visitCase ( const RexCase *  rex_case ) const

inlineoverrideprotectedvirtual

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

Definition at line 193 of file RexVisitor.h.

References RexCase::branchCount(), RexCase::getElse(), RexCase::getThen(), RexCase::getWhen(), and RexVisitorBase< T >::visit().

                                                            {
    std::vector<std::pair<RetType, RetType>> new_pair_list;
    for (size_t i = 0; i < rex_case->branchCount(); ++i) {
      new_pair_list.emplace_back(visit(rex_case->getWhen(i)),
                                 visit(rex_case->getThen(i)));
    }
    auto new_else = visit(rex_case->getElse());
    return std::make_unique<RexCase>(new_pair_list, new_else);
  }

Here is the call graph for this function:

visitInput()

RetType RexDeepCopyVisitor::visitInput ( const RexInput *  input ) const

inlineoverrideprotectedvirtual

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

Reimplemented in RexInputRenumber< bAllowMissing >.

Definition at line 141 of file RexVisitor.h.

References RexInput::deepCopy().

Referenced by anonymous_namespace{RelAlgOptimizer.cpp}::SubConditionReplacer::visitInput().

{ return input->deepCopy(); }

Here is the call graph for this function:

Here is the caller graph for this function:

visitLiteral()

RetType RexDeepCopyVisitor::visitLiteral ( const RexLiteral *  literal ) const

inlineoverrideprotectedvirtual

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

Definition at line 143 of file RexVisitor.h.

                                                                 {
    return literal->deepCopy();
  }

visitOperator()

RetType RexDeepCopyVisitor::visitOperator ( const RexOperator *  rex_operator ) const

inlineoverrideprotectedvirtual

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

Definition at line 153 of file RexVisitor.h.

References RexOperator::getDisambiguated(), RexOperator::getOperand(), RexOperator::size(), and RexVisitorBase< T >::visit().

Referenced by SubConditionRemover::visitOperator().

                                                                        {
    const auto rex_window_function_operator =
        dynamic_cast<const RexWindowFunctionOperator*>(rex_operator);
    if (rex_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) {
      new_opnds.push_back(visit(rex_operator->getOperand(i)));
    }
    return rex_operator->getDisambiguated(new_opnds);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

visitRef()

RetType RexDeepCopyVisitor::visitRef ( const RexRef *  ref ) const

inlineoverrideprotectedvirtual

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

Definition at line 151 of file RexVisitor.h.

References RexRef::deepCopy().

{ return ref->deepCopy(); }

Here is the call graph for this function:

visitSubQuery()

RetType RexDeepCopyVisitor::visitSubQuery ( const RexSubQuery *  subquery ) const

inlineoverrideprotectedvirtual

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

Definition at line 147 of file RexVisitor.h.

                                                                    {
    return subquery->deepCopy();
  }

visitWindowFunctionOperator()

RetType RexDeepCopyVisitor::visitWindowFunctionOperator ( const RexWindowFunctionOperator *  rex_window_function_operator ) const

inlineprotected

Definition at line 168 of file RexVisitor.h.

References RexWindowFunctionOperator::disambiguatedOperands(), RexWindowFunctionOperator::getCollation(), RexOperator::getOperand(), RexWindowFunctionOperator::getOrderKeys(), RexWindowFunctionOperator::getPartitionKeys(), RexOperator::size(), and RexVisitorBase< T >::visit().

                                                                           {
    const size_t operand_count = rex_window_function_operator->size();
    std::vector<RetType> new_opnds;
    for (size_t i = 0; i < operand_count; ++i) {
      new_opnds.push_back(visit(rex_window_function_operator->getOperand(i)));
    }

    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(visit(partition_key.get()));
    }
    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(visit(order_key.get()));
    }
    return rex_window_function_operator->disambiguatedOperands(
        new_opnds,
        disambiguated_partition_keys,
        disambiguated_order_keys,
        rex_window_function_operator->getCollation());
  }

Here is the call graph for this function:

---

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

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/RexVisitor.h