#include <RelAlgDag.h>

Inheritance diagram for RexWindowFunctionOperator:

Collaboration diagram for RexWindowFunctionOperator:

Classes
struct	RexWindowBound

Public Member Functions
	RexWindowFunctionOperator ()

	RexWindowFunctionOperator (const SqlWindowFunctionKind kind, ConstRexScalarPtrVector &operands, ConstRexScalarPtrVector &partition_keys, ConstRexScalarPtrVector &order_keys, const std::vector< SortField > collation, const RexWindowBound &frame_start_bound, const RexWindowBound &frame_end_bound, const bool is_rows, const SQLTypeInfo &ti)

virtual void	acceptChildren (Visitor &v) const override

virtual void	accept (Visitor &v, std::string name) const override

SqlWindowFunctionKind	getKind () const

const ConstRexScalarPtrVector &	getPartitionKeys () const

ConstRexScalarPtrVector	getPartitionKeysAndRelease () const

ConstRexScalarPtrVector	getOrderKeysAndRelease () const

const ConstRexScalarPtrVector &	getOrderKeys () const

void	replacePartitionKey (size_t offset, std::unique_ptr< const RexScalar > &&new_partition_key)

void	replaceOrderKey (size_t offset, std::unique_ptr< const RexScalar > &&new_order_key)

void	replaceOperands (std::vector< std::unique_ptr< const RexScalar >> &&new_operands)

const std::vector< SortField > &	getCollation () const

const RexWindowBound &	getFrameStartBound () const

const RexWindowBound &	getFrameEndBound () const

bool	isRows () const

std::unique_ptr< const RexOperator >	disambiguatedOperands (ConstRexScalarPtrVector &operands, ConstRexScalarPtrVector &partition_keys, ConstRexScalarPtrVector &order_keys, const std::vector< SortField > &collation) const

std::string	toString (RelRexToStringConfig config=RelRexToStringConfig::defaults()) const override

virtual size_t	toHash () const override

Public Member Functions inherited from RexFunctionOperator
	RexFunctionOperator ()=default

	RexFunctionOperator (const std::string &name, ConstRexScalarPtrVector &operands, const SQLTypeInfo &ti)

std::unique_ptr< const RexOperator >	getDisambiguated (std::vector< std::unique_ptr< const RexScalar >> &operands) const override

const std::string &	getName () const

Public Member Functions inherited from RexOperator
	RexOperator ()

	RexOperator (const SQLOps op, std::vector< std::unique_ptr< const RexScalar >> &operands, const SQLTypeInfo &type)

size_t	size () const

const RexScalar *	getOperand (const size_t idx) const

const RexScalar *	getOperandAndRelease (const size_t idx) const

SQLOps	getOperator () const

const SQLTypeInfo &	getType () const

Public Member Functions inherited from Rex
virtual	~Rex ()

virtual size_t	getStepNumber () const

Public Member Functions inherited from RelAlgDagNode
	RelAlgDagNode ()

virtual void	setStepNumber (size_t step) const

std::optional< size_t >	getIdInPlanTree () const

void	setIdInPlanTree (size_t id) const

Private Attributes
SqlWindowFunctionKind	kind_

ConstRexScalarPtrVector	partition_keys_

ConstRexScalarPtrVector	order_keys_

std::vector< SortField >	collation_

RexWindowBound	frame_start_bound_

RexWindowBound	frame_end_bound_

bool	is_rows_

Friends
struct	RelAlgDagSerializer

std::size_t	hash_value (RexWindowFunctionOperator const &)

Additional Inherited Members
Public Types inherited from RexFunctionOperator
using	ConstRexScalarPtr = std::unique_ptr< const RexScalar >

using	ConstRexScalarPtrVector = std::vector< ConstRexScalarPtr >

Protected Attributes inherited from RexOperator
SQLOps	op_

std::vector< std::unique_ptr < const RexScalar > >	operands_

SQLTypeInfo	type_

Protected Attributes inherited from Rex
std::optional< size_t >	hash_

Protected Attributes inherited from RelAlgDagNode
size_t	step_ {0}

std::optional< size_t >	id_in_plan_tree_

Detailed Description

Definition at line 574 of file RelAlgDag.h.

Constructor & Destructor Documentation

RexWindowFunctionOperator::RexWindowFunctionOperator ( )

inline

Definition at line 602 of file RelAlgDag.h.

References UNKNOWN.

Referenced by disambiguatedOperands().

603 : RexFunctionOperator(), kind_{SqlWindowFunctionKind::UNKNOWN}, is_rows_{false} {}

RexFunctionOperator::RexFunctionOperator

RexFunctionOperator()=default

RexWindowFunctionOperator::kind_

SqlWindowFunctionKind kind_

Definition: RelAlgDag.h:721

SqlWindowFunctionKind::UNKNOWN

RexWindowFunctionOperator::is_rows_

bool is_rows_

Definition: RelAlgDag.h:727

Here is the caller graph for this function:

RexWindowFunctionOperator::RexWindowFunctionOperator	(	const SqlWindowFunctionKind	kind,
		ConstRexScalarPtrVector &	operands,
		ConstRexScalarPtrVector &	partition_keys,
		ConstRexScalarPtrVector &	order_keys,
		const std::vector< SortField >	collation,
		const RexWindowBound &	frame_start_bound,
		const RexWindowBound &	frame_end_bound,
		const bool	is_rows,
		const SQLTypeInfo &	ti
	)

inline

Definition at line 605 of file RelAlgDag.h.

       : RexFunctionOperator(::toString(kind), operands, ti)
       , kind_(kind)
       , partition_keys_(std::move(partition_keys))
       , order_keys_(std::move(order_keys))
       , collation_(collation)
       , frame_start_bound_(frame_start_bound)
       , frame_end_bound_(frame_end_bound)
       , is_rows_(is_rows) {}

Member Function Documentation

virtual void RexWindowFunctionOperator::accept	(	Visitor &	v,
		std::string	name
	)		const

inlineoverridevirtual

Reimplemented from RexFunctionOperator.

Definition at line 635 of file RelAlgDag.h.

References acceptChildren(), and RelAlgDagNode::Visitor::visit().

Referenced by TableFunctionsFactory_node.PrintNode::__str__().

                                                                  {
     if (v.visit(this, std::move(name))) {
       acceptChildren(v);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void RexWindowFunctionOperator::acceptChildren ( Visitor & v ) const

inlineoverridevirtual

Reimplemented from RexFunctionOperator.

Definition at line 623 of file RelAlgDag.h.

References getOrderKeys(), and getPartitionKeys().

Referenced by accept().

                                                          {
     for (auto const& partition_key : getPartitionKeys()) {
       if (partition_key) {
         partition_key->accept(v, "partition");
       }
     }
     for (auto const& order_key : getOrderKeys()) {
       if (order_key) {
         order_key->accept(v, "order");
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<const RexOperator> RexWindowFunctionOperator::disambiguatedOperands	(	ConstRexScalarPtrVector &	operands,
		ConstRexScalarPtrVector &	partition_keys,
		ConstRexScalarPtrVector &	order_keys,
		const std::vector< SortField > &	collation
	)		const

inline

Definition at line 678 of file RelAlgDag.h.

References getFrameEndBound(), getFrameStartBound(), RexOperator::getType(), isRows(), kind_, and RexWindowFunctionOperator().

Referenced by RexDeepCopyVisitor::visitWindowFunctionOperator().

                                                    {
     return std::unique_ptr<const RexOperator>(
         new RexWindowFunctionOperator(kind_,
                                       operands,
                                       partition_keys,
                                       order_keys,
                                       collation,
                                       getFrameStartBound(),
                                       getFrameEndBound(),
                                       isRows(),
                                       getType()));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

const std::vector<SortField>& RexWindowFunctionOperator::getCollation ( ) const

inline

Definition at line 670 of file RelAlgDag.h.

References collation_.

Referenced by RelAlgTranslator::translateWindowFunction(), and RexDeepCopyVisitor::visitWindowFunctionOperator().

670 { return collation_; }

RexWindowFunctionOperator::collation_

std::vector< SortField > collation_

Definition: RelAlgDag.h:724

Here is the caller graph for this function:

const RexWindowBound& RexWindowFunctionOperator::getFrameEndBound ( ) const

inline

Definition at line 674 of file RelAlgDag.h.

References frame_end_bound_.

Referenced by disambiguatedOperands(), and RelAlgTranslator::translateWindowFunction().

674 { return frame_end_bound_; }

RexWindowFunctionOperator::frame_end_bound_

RexWindowBound frame_end_bound_

Definition: RelAlgDag.h:726

Here is the caller graph for this function:

const RexWindowBound& RexWindowFunctionOperator::getFrameStartBound ( ) const

inline

Definition at line 672 of file RelAlgDag.h.

References frame_start_bound_.

Referenced by disambiguatedOperands(), and RelAlgTranslator::translateWindowFunction().

672 { return frame_start_bound_; }

RexWindowFunctionOperator::frame_start_bound_

RexWindowBound frame_start_bound_

Definition: RelAlgDag.h:725

Here is the caller graph for this function:

SqlWindowFunctionKind RexWindowFunctionOperator::getKind ( ) const

inline

Definition at line 641 of file RelAlgDag.h.

References kind_.

Referenced by RelAlgTranslator::translateWindowFunction().

641 { return kind_; }

RexWindowFunctionOperator::kind_

SqlWindowFunctionKind kind_

Definition: RelAlgDag.h:721

Here is the caller graph for this function:

const ConstRexScalarPtrVector& RexWindowFunctionOperator::getOrderKeys ( ) const

inline

Definition at line 653 of file RelAlgDag.h.

References order_keys_.

Referenced by acceptChildren(), anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::find_generic_expr_in_window_func(), anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::pushDownExpressionInWindowFunction(), RelAlgTranslator::translateWindowFunction(), RelRexDagVisitor::visit(), RexVisitor< T >::visitWindowFunctionOperator(), and RexDeepCopyVisitor::visitWindowFunctionOperator().

653 { return order_keys_; }

RexWindowFunctionOperator::order_keys_

ConstRexScalarPtrVector order_keys_

Definition: RelAlgDag.h:723

Here is the caller graph for this function:

ConstRexScalarPtrVector RexWindowFunctionOperator::getOrderKeysAndRelease ( ) const

inline

Definition at line 649 of file RelAlgDag.h.

References order_keys_.

                                                          {
     return std::move(order_keys_);
   }

const ConstRexScalarPtrVector& RexWindowFunctionOperator::getPartitionKeys ( ) const

inline

Definition at line 643 of file RelAlgDag.h.

References partition_keys_.

Referenced by acceptChildren(), anonymous_namespace{RelAlgDag.cpp}::disambiguate_operator(), anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::find_generic_expr_in_window_func(), anonymous_namespace{RelAlgDag.cpp}::PushDownGenericExpressionInWindowFunction::pushDownExpressionInWindowFunction(), RelAlgTranslator::translateWindowFunction(), RelRexDagVisitor::visit(), RexVisitor< T >::visitWindowFunctionOperator(), and RexDeepCopyVisitor::visitWindowFunctionOperator().

643 { return partition_keys_; }

RexWindowFunctionOperator::partition_keys_

ConstRexScalarPtrVector partition_keys_

Definition: RelAlgDag.h:722

Here is the caller graph for this function:

ConstRexScalarPtrVector RexWindowFunctionOperator::getPartitionKeysAndRelease ( ) const

inline

Definition at line 645 of file RelAlgDag.h.

References partition_keys_.

                                                              {
     return std::move(partition_keys_);
   }

bool RexWindowFunctionOperator::isRows ( ) const

inline

Definition at line 676 of file RelAlgDag.h.

References is_rows_.

Referenced by disambiguatedOperands(), and RelAlgTranslator::translateWindowFunction().

676 { return is_rows_; }

RexWindowFunctionOperator::is_rows_

bool is_rows_

Definition: RelAlgDag.h:727

Here is the caller graph for this function:

void RexWindowFunctionOperator::replaceOperands ( std::vector< std::unique_ptr< const RexScalar >> && new_operands )

inline

Definition at line 666 of file RelAlgDag.h.

References RexOperator::operands_.

                                                                                  {
     operands_ = std::move(new_operands);
   }

void RexWindowFunctionOperator::replaceOrderKey	(	size_t	offset,
		std::unique_ptr< const RexScalar > &&	new_order_key
	)

inline

Definition at line 661 of file RelAlgDag.h.

References CHECK_LT, and order_keys_.

                                                                                       {
     CHECK_LT(offset, order_keys_.size());
     order_keys_[offset] = std::move(new_order_key);
   }

void RexWindowFunctionOperator::replacePartitionKey	(	size_t	offset,
		std::unique_ptr< const RexScalar > &&	new_partition_key
	)

inline

Definition at line 655 of file RelAlgDag.h.

References CHECK_LT, and partition_keys_.

                                                                                {
     CHECK_LT(offset, partition_keys_.size());
     partition_keys_[offset] = std::move(new_partition_key);
   }

virtual size_t RexWindowFunctionOperator::toHash ( ) const

inlineoverridevirtual

Reimplemented from RexFunctionOperator.

Definition at line 716 of file RelAlgDag.h.

References hash_value.

716 { return hash_value(*this); }

RexWindowFunctionOperator::hash_value

friend std::size_t hash_value(RexWindowFunctionOperator const &)

Definition: RelAlgDag.cpp:3622

std::string RexWindowFunctionOperator::toString ( RelRexToStringConfig config = RelRexToStringConfig::defaults() ) const

inlineoverridevirtual

Reimplemented from RexFunctionOperator.

Definition at line 695 of file RelAlgDag.h.

References cat(), RexFunctionOperator::getName(), RexOperator::operands_, order_keys_, partition_keys_, and typeName().

                                                                                    {
     if (!config.attributes_only) {
       auto ret = cat(::typeName(this), "(", getName(), ", operands=");
       for (auto& operand : operands_) {
         ret += operand->toString(config) + " ";
       }
       ret += ", partition_keys=";
       for (auto& key : partition_keys_) {
         ret += key->toString(config) + " ";
       }
       ret += ", order_keys=";
       for (auto& key : order_keys_) {
         ret += key->toString(config) + " ";
       }
       return cat(ret, ")");
     } else {
       return cat(::typeName(this), "(", getName(), ")");
     }
   }

Here is the call graph for this function:

Friends And Related Function Documentation

std::size_t hash_value ( RexWindowFunctionOperator const & rex_window )

friend

Definition at line 3622 of file RelAlgDag.cpp.

Referenced by toHash().

                                                                   {
   if (rex_window.hash_) {
     return *rex_window.hash_;
   }
   rex_window.hash_ = typeid(RexWindowFunctionOperator).hash_code();
   boost::hash_combine(*rex_window.hash_, rex_window.getType().get_type_name());
   boost::hash_combine(*rex_window.hash_, rex_window.getName());
   boost::hash_combine(*rex_window.hash_, rex_window.is_rows_);
   boost::hash_combine(*rex_window.hash_, rex_window.collation_);
   boost::hash_combine(*rex_window.hash_, rex_window.operands_);
   boost::hash_combine(*rex_window.hash_, rex_window.partition_keys_);
   boost::hash_combine(*rex_window.hash_, rex_window.order_keys_);
   auto get_window_bound_hash =
       [](const RexWindowFunctionOperator::RexWindowBound& bound) {
         auto h = boost::hash_value(bound.bound_expr);
         boost::hash_combine(h, bound.unbounded);
         boost::hash_combine(h, bound.preceding);
         boost::hash_combine(h, bound.following);
         boost::hash_combine(h, bound.is_current_row);
         boost::hash_combine(h, bound.order_key);
         return h;
       };
   boost::hash_combine(*rex_window.hash_,
                       get_window_bound_hash(rex_window.frame_start_bound_));
   boost::hash_combine(*rex_window.hash_,
                       get_window_bound_hash(rex_window.frame_end_bound_));
   return *rex_window.hash_;
 }