anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction Class Reference

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

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

Public Types
enum	WindowExprType { WindowExprType::PARTITION_KEY, WindowExprType::ORDER_KEY }

Public Member Functions
	PushDownGenericExpressionInWindowFunction (std::shared_ptr< RelProject > new_project, std::vector< std::unique_ptr< const RexScalar >> &scalar_exprs_for_new_project, std::vector< std::string > &fields_for_new_project, std::unordered_map< size_t, size_t > &expr_offset_cache)
size_t	pushDownExpressionImpl (const RexScalar *expr) const
std::optional< size_t >	getOffsetForPushedDownExpr (WindowExprType type, size_t expr_offset) const
void	pushDownExpressionInWindowFunction (const RexWindowFunctionOperator *window_expr) const
std::unique_ptr< const RexScalar >	visitInput (const RexInput *rex_input) const override
std::unique_ptr< const RexScalar >	visitLiteral (const RexLiteral *rex_literal) const override
std::unique_ptr< const RexScalar >	visitRef (const RexRef *rex_ref) const override
std::unique_ptr< const RexScalar >	visitSubQuery (const RexSubQuery *rex_subquery) const override
std::unique_ptr< const RexScalar >	visitCase (const RexCase *rex_case) const override
std::unique_ptr< const RexScalar >	visitOperator (const RexOperator *rex_operator) const override
bool	hasCaseExprAsWindowOperand ()
bool	hasPartitionExpression ()
Public Member Functions inherited from RexVisitorBase< std::unique_ptr< const RexScalar > >
virtual std::unique_ptr< const RexScalar >	visit (const RexScalar *rex_scalar) const

Private Member Functions
std::unique_ptr< const RexScalar >	defaultResult () const override

Private Attributes
std::shared_ptr< RelProject >	new_project_
std::vector< std::unique_ptr < const RexScalar > > &	scalar_exprs_for_new_project_
std::vector< std::string > &	fields_for_new_project_
std::unordered_map< size_t, size_t > &	expr_offset_cache_
bool	found_case_expr_window_operand_
bool	has_partition_expr_
std::unordered_map< size_t, size_t >	pushed_down_window_operands_offset_
std::unordered_map< size_t, size_t >	pushed_down_partition_key_offset_
std::unordered_map< size_t, size_t >	pushed_down_order_key_offset_
RexDeepCopyVisitor	deep_copier_

Additional Inherited Members

Detailed Description

Definition at line 125 of file RelAlgDag.cpp.

Member Enumeration Documentation

enum anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::WindowExprType

strong

Enumerator
PARTITION_KEY
ORDER_KEY

Definition at line 128 of file RelAlgDag.cpp.

{ PARTITION_KEY, ORDER_KEY };

Constructor & Destructor Documentation

anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::PushDownGenericExpressionInWindowFunction ( std::shared_ptr< RelProject >  new_project, std::vector< std::unique_ptr< const RexScalar >> &  scalar_exprs_for_new_project, std::vector< std::string > &  fields_for_new_project, std::unordered_map< size_t, size_t > &  expr_offset_cache  )

inline

Definition at line 129 of file RelAlgDag.cpp.

      : new_project_(new_project)
      , scalar_exprs_for_new_project_(scalar_exprs_for_new_project)
      , fields_for_new_project_(fields_for_new_project)
      , expr_offset_cache_(expr_offset_cache)
      , found_case_expr_window_operand_(false)
      , has_partition_expr_(false) {}

Member Function Documentation

std::unique_ptr<const RexScalar> anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::defaultResult ( ) const

inlineoverrideprivatevirtual

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

Definition at line 330 of file RelAlgDag.cpp.

{ return nullptr; }

std::optional<size_t> anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::getOffsetForPushedDownExpr ( WindowExprType  type, size_t  expr_offset  ) const

inline

Definition at line 158 of file RelAlgDag.cpp.

References CHECK, and UNREACHABLE.

                                                                             {
    // given window expr offset and inner expr's offset,
    // return a (push-downed) expression's offset from the new projection node
    switch (type) {
      case WindowExprType::PARTITION_KEY: {
        auto it = pushed_down_partition_key_offset_.find(expr_offset);
        CHECK(it != pushed_down_partition_key_offset_.end());
        return it->second;
      }
      case WindowExprType::ORDER_KEY: {
        auto it = pushed_down_order_key_offset_.find(expr_offset);
        CHECK(it != pushed_down_order_key_offset_.end());
        return it->second;
      }
      default:
        UNREACHABLE();
        return std::nullopt;
    }
  }

bool anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::hasCaseExprAsWindowOperand ( )

inline

Definition at line 325 of file RelAlgDag.cpp.

{ return found_case_expr_window_operand_; }

bool anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::hasPartitionExpression ( )

inline

Definition at line 327 of file RelAlgDag.cpp.

{ return has_partition_expr_; }

size_t anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::pushDownExpressionImpl ( const RexScalar *  expr ) const

inline

Definition at line 141 of file RelAlgDag.cpp.

References CHECK, and Rex::toHash().

                                                             {
    auto hash = expr->toHash();
    auto it = expr_offset_cache_.find(hash);
    auto new_offset = -1;
    if (it == expr_offset_cache_.end()) {
      CHECK(
          expr_offset_cache_.emplace(hash, scalar_exprs_for_new_project_.size()).second);
      new_offset = scalar_exprs_for_new_project_.size();
      fields_for_new_project_.emplace_back("");
      scalar_exprs_for_new_project_.emplace_back(deep_copier_.visit(expr));
    } else {
      // we already pushed down the same expression, so reuse it
      new_offset = it->second;
    }
    return new_offset;
  }

Here is the call graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::pushDownExpressionInWindowFunction ( const RexWindowFunctionOperator *  window_expr ) const

inline

Definition at line 179 of file RelAlgDag.cpp.

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

                                                          {
    // step 1. push "all" target expressions of the window_func_project_node down to the
    // new child projection
    // each window expr is a separate target expression of the projection node
    // and they have their own inner expression related to partition / order clauses
    // so we capture their offsets to correctly rebind their input
    pushed_down_window_operands_offset_.clear();
    pushed_down_partition_key_offset_.clear();
    pushed_down_order_key_offset_.clear();
    for (size_t offset = 0; offset < window_expr->size(); ++offset) {
      auto expr = window_expr->getOperand(offset);
      auto literal_expr = dynamic_cast<const RexLiteral*>(expr);
      auto case_expr = dynamic_cast<const RexCase*>(expr);
      if (case_expr) {
        // when columnar output is enabled, pushdown case expr can incur an issue
        // during columnarization, so we record this and try to force rowwise-output
        // until we fix the issue
        // todo (yoonmin) : relax this
        found_case_expr_window_operand_ = true;
      }
      if (!literal_expr) {
        auto new_offset = pushDownExpressionImpl(expr);
        pushed_down_window_operands_offset_.emplace(offset, new_offset);
      }
    }
    size_t offset = 0;
    for (const auto& partition_key : window_expr->getPartitionKeys()) {
      auto new_offset = pushDownExpressionImpl(partition_key.get());
      pushed_down_partition_key_offset_.emplace(offset, new_offset);
      ++offset;
    }
    has_partition_expr_ = !window_expr->getPartitionKeys().empty();
    offset = 0;
    for (const auto& order_key : window_expr->getOrderKeys()) {
      auto new_offset = pushDownExpressionImpl(order_key.get());
      pushed_down_order_key_offset_.emplace(offset, new_offset);
      ++offset;
    }

    // step 2. rebind projected targets of the window_func_project_node with the new
    // project node
    std::vector<std::unique_ptr<const RexScalar>> window_operands;
    auto deconst_window_expr = const_cast<RexWindowFunctionOperator*>(window_expr);
    for (size_t idx = 0; idx < window_expr->size(); ++idx) {
      auto it = pushed_down_window_operands_offset_.find(idx);
      if (it != pushed_down_window_operands_offset_.end()) {
        auto new_input = std::make_unique<const RexInput>(new_project_.get(), it->second);
        CHECK(new_input);
        window_operands.emplace_back(std::move(new_input));
      } else {
        auto copied_expr = deep_copier_.visit(window_expr->getOperand(idx));
        window_operands.emplace_back(std::move(copied_expr));
      }
    }
    deconst_window_expr->replaceOperands(std::move(window_operands));

    for (size_t idx = 0; idx < window_expr->getPartitionKeys().size(); ++idx) {
      auto new_offset = getOffsetForPushedDownExpr(WindowExprType::PARTITION_KEY, idx);
      CHECK(new_offset);
      auto new_input = std::make_unique<const RexInput>(new_project_.get(), *new_offset);
      CHECK(new_input);
      deconst_window_expr->replacePartitionKey(idx, std::move(new_input));
    }

    for (size_t idx = 0; idx < window_expr->getOrderKeys().size(); ++idx) {
      auto new_offset = getOffsetForPushedDownExpr(WindowExprType::ORDER_KEY, idx);
      CHECK(new_offset);
      auto new_input = std::make_unique<const RexInput>(new_project_.get(), *new_offset);
      CHECK(new_input);
      deconst_window_expr->replaceOrderKey(idx, std::move(new_input));
    }
  }

Here is the call graph for this function:

std::unique_ptr<const RexScalar> anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::visitCase ( const RexCase *  rex_case ) const

inlineoverridevirtual

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

Definition at line 279 of file RelAlgDag.cpp.

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

                                                                                   {
    std::vector<
        std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
        new_expr_pair_list;
    std::unique_ptr<const RexScalar> new_else_expr;
    for (size_t i = 0; i < rex_case->branchCount(); ++i) {
      const auto when = rex_case->getWhen(i);
      auto new_when = PushDownGenericExpressionInWindowFunction::visit(when);
      const auto then = rex_case->getThen(i);
      auto new_then = PushDownGenericExpressionInWindowFunction::visit(then);
      new_expr_pair_list.emplace_back(std::move(new_when), std::move(new_then));
    }
    if (rex_case->getElse()) {
      new_else_expr = deep_copier_.visit(rex_case->getElse());
    }
    auto new_case = std::make_unique<const RexCase>(new_expr_pair_list, new_else_expr);
    return new_case;
  }

Here is the call graph for this function:

std::unique_ptr<const RexScalar> anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::visitInput ( const RexInput *  rex_input ) const

inlineoverridevirtual

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

Definition at line 253 of file RelAlgDag.cpp.

References CHECK, CHECK_EQ, CHECK_LT, and RexInput::toHash().

                                                                                      {
    auto new_offset = pushDownExpressionImpl(rex_input);
    CHECK_LT(new_offset, scalar_exprs_for_new_project_.size());
    auto hash = rex_input->toHash();
    auto it = expr_offset_cache_.find(hash);
    CHECK(it != expr_offset_cache_.end());
    CHECK_EQ(new_offset, it->second);
    auto new_input = std::make_unique<const RexInput>(new_project_.get(), new_offset);
    CHECK(new_input);
    return new_input;
  }

Here is the call graph for this function:

std::unique_ptr<const RexScalar> anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::visitLiteral ( const RexLiteral *  rex_literal ) const

inlineoverridevirtual

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

Definition at line 265 of file RelAlgDag.cpp.

                                                    {
    return deep_copier_.visit(rex_literal);
  }

std::unique_ptr<const RexScalar> anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::visitOperator ( const RexOperator *  rex_operator ) const

inlineoverridevirtual

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

Definition at line 298 of file RelAlgDag.cpp.

References CHECK, RexOperator::getOperand(), RexOperator::getOperator(), RexOperator::getType(), and RexOperator::size().

                                                      {
    const auto rex_window_func_operator =
        dynamic_cast<const RexWindowFunctionOperator*>(rex_operator);
    if (rex_window_func_operator) {
      pushDownExpressionInWindowFunction(rex_window_func_operator);
      return deep_copier_.visit(rex_operator);
    } else {
      std::unique_ptr<const RexOperator> new_operator{nullptr};
      std::vector<std::unique_ptr<const RexScalar>> new_operands;
      for (size_t i = 0; i < rex_operator->size(); ++i) {
        const auto operand = rex_operator->getOperand(i);
        auto new_operand = PushDownGenericExpressionInWindowFunction::visit(operand);
        new_operands.emplace_back(std::move(new_operand));
      }
      if (auto function_op = dynamic_cast<const RexFunctionOperator*>(rex_operator)) {
        new_operator = std::make_unique<const RexFunctionOperator>(
            function_op->getName(), new_operands, rex_operator->getType());
      } else {
        new_operator = std::make_unique<const RexOperator>(
            rex_operator->getOperator(), new_operands, rex_operator->getType());
      }
      CHECK(new_operator);
      return new_operator;
    }
  }

Here is the call graph for this function:

std::unique_ptr<const RexScalar> anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::visitRef ( const RexRef *  rex_ref ) const

inlineoverridevirtual

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

Definition at line 270 of file RelAlgDag.cpp.

                                                                                {
    return deep_copier_.visit(rex_ref);
  }

std::unique_ptr<const RexScalar> anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::visitSubQuery ( const RexSubQuery *  rex_subquery ) const

inlineoverridevirtual

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

Definition at line 274 of file RelAlgDag.cpp.

                                                      {
    return deep_copier_.visit(rex_subquery);
  }

Member Data Documentation

RexDeepCopyVisitor anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::deep_copier_

private

Definition at line 341 of file RelAlgDag.cpp.

std::unordered_map<size_t, size_t>& anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::expr_offset_cache_

private

Definition at line 335 of file RelAlgDag.cpp.

std::vector<std::string>& anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::fields_for_new_project_

private

Definition at line 334 of file RelAlgDag.cpp.

bool anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::found_case_expr_window_operand_

mutableprivate

Definition at line 336 of file RelAlgDag.cpp.

bool anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::has_partition_expr_

mutableprivate

Definition at line 337 of file RelAlgDag.cpp.

std::shared_ptr<RelProject> anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::new_project_

private

Definition at line 332 of file RelAlgDag.cpp.

std::unordered_map<size_t, size_t> anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::pushed_down_order_key_offset_

mutableprivate

Definition at line 340 of file RelAlgDag.cpp.

std::unordered_map<size_t, size_t> anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::pushed_down_partition_key_offset_

mutableprivate

Definition at line 339 of file RelAlgDag.cpp.

std::unordered_map<size_t, size_t> anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::pushed_down_window_operands_offset_

mutableprivate

Definition at line 338 of file RelAlgDag.cpp.

std::vector<std::unique_ptr<const RexScalar> >& anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::scalar_exprs_for_new_project_

private

Definition at line 333 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