#include <RelAlgDag.h>

Inheritance diagram for RelTranslatedJoin:

Collaboration diagram for RelTranslatedJoin:

Public Member Functions
	RelTranslatedJoin (const RelAlgNode lhs, const RelAlgNode rhs, const std::vector< const Analyzer::ColumnVar * > lhs_join_cols, const std::vector< const Analyzer::ColumnVar * > rhs_join_cols, const std::vector< std::shared_ptr< const Analyzer::Expr >> filter_ops, const RexScalar *outer_join_cond, const bool nested_loop, const JoinType join_type, const std::string &op_type, const std::string &qualifier, const std::string &op_typeinfo)

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

size_t	toHash () const override

const RelAlgNode *	getLHS () const

const RelAlgNode *	getRHS () const

size_t	getFilterCondSize () const

const std::vector < std::shared_ptr< const Analyzer::Expr > >	getFilterCond () const

const RexScalar *	getOuterJoinCond () const

std::string	getOpType () const

std::string	getQualifier () const

std::string	getOpTypeInfo () const

size_t	size () const override

JoinType	getJoinType () const

const RexScalar *	getCondition () const

const RexScalar *	getAndReleaseCondition () const

void	setCondition (std::unique_ptr< const RexScalar > &condition)

void	replaceInput (std::shared_ptr< const RelAlgNode > old_input, std::shared_ptr< const RelAlgNode > input) override

std::shared_ptr< RelAlgNode >	deepCopy () const override

std::string	getFieldName (const size_t i) const

std::vector< const Analyzer::ColumnVar * >	getJoinCols (bool lhs) const

bool	isNestedLoopQual () const

Public Member Functions inherited from RelAlgNode
	RelAlgNode (RelAlgInputs inputs={})

virtual	~RelAlgNode ()

void	resetQueryExecutionState ()

void	setContextData (const RaExecutionDesc *context_data) const

void	setOutputMetainfo (std::vector< TargetMetaInfo > targets_metainfo) const

void	setQueryPlanDag (const std::string &extracted_query_plan_dag) const

std::string	getQueryPlanDag () const

size_t	getQueryPlanDagHash () const

const std::vector < TargetMetaInfo > &	getOutputMetainfo () const

unsigned	getId () const

void	setIdInPlanTree (size_t id) const

std::optional< size_t >	getIdInPlanTree () const

bool	hasContextData () const

const RaExecutionDesc *	getContextData () const

const size_t	inputCount () const

const RelAlgNode *	getInput (const size_t idx) const

std::shared_ptr< const RelAlgNode >	getAndOwnInput (const size_t idx) const

void	addManagedInput (std::shared_ptr< const RelAlgNode > input)

bool	hasInput (const RelAlgNode *needle) const

void	setRelNodeDagId (const size_t id) const

size_t	getRelNodeDagId () const

bool	isNop () const

void	markAsNop ()

void	clearContextData () const

Private Attributes
const RelAlgNode *	lhs_

const RelAlgNode *	rhs_

const std::vector< const Analyzer::ColumnVar * >	lhs_join_cols_

const std::vector< const Analyzer::ColumnVar * >	rhs_join_cols_

const std::vector < std::shared_ptr< const Analyzer::Expr > >	filter_ops_

const RexScalar *	outer_join_cond_

const bool	nested_loop_

const JoinType	join_type_

const std::string	op_type_

const std::string	qualifier_

const std::string	op_typeinfo_

Additional Inherited Members
Static Public Member Functions inherited from RelAlgNode
static void	resetRelAlgFirstId () noexcept

Protected Attributes inherited from RelAlgNode
RelAlgInputs	inputs_

unsigned	id_

std::optional< size_t >	id_in_plan_tree_

std::optional< size_t >	hash_

Detailed Description

Definition at line 1560 of file RelAlgDag.h.

Constructor & Destructor Documentation

RelTranslatedJoin::RelTranslatedJoin	(	const RelAlgNode *	lhs,
		const RelAlgNode *	rhs,
		const std::vector< const Analyzer::ColumnVar * >	lhs_join_cols,
		const std::vector< const Analyzer::ColumnVar * >	rhs_join_cols,
		const std::vector< std::shared_ptr< const Analyzer::Expr >>	filter_ops,
		const RexScalar *	outer_join_cond,
		const bool	nested_loop,
		const JoinType	join_type,
		const std::string &	op_type,
		const std::string &	qualifier,
		const std::string &	op_typeinfo
	)

inline

Definition at line 1562 of file RelAlgDag.h.

Referenced by toHash().

       : lhs_(lhs)
       , rhs_(rhs)
       , lhs_join_cols_(lhs_join_cols)
       , rhs_join_cols_(rhs_join_cols)
       , filter_ops_(filter_ops)
       , outer_join_cond_(outer_join_cond)
       , nested_loop_(nested_loop)
       , join_type_(join_type)
       , op_type_(op_type)
       , qualifier_(qualifier)
       , op_typeinfo_(op_typeinfo) {}

Here is the caller graph for this function:

Member Function Documentation

std::shared_ptr<RelAlgNode> RelTranslatedJoin::deepCopy ( ) const

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 1650 of file RelAlgDag.h.

References CHECK.

                                                       {
     CHECK(false);
     return nullptr;
   }

const RexScalar* RelTranslatedJoin::getAndReleaseCondition ( ) const

inline

Definition at line 1641 of file RelAlgDag.h.

References CHECK.

                                                   {
     CHECK(false);
     return nullptr;
   }

const RexScalar* RelTranslatedJoin::getCondition ( ) const

inline

Definition at line 1637 of file RelAlgDag.h.

References CHECK.

                                         {
     CHECK(false);
     return nullptr;
   }

std::string RelTranslatedJoin::getFieldName ( const size_t i ) const

const std::vector<std::shared_ptr<const Analyzer::Expr> > RelTranslatedJoin::getFilterCond ( ) const

inline

Definition at line 1628 of file RelAlgDag.h.

References filter_ops_.

                                                                            {
     return filter_ops_;
   }

size_t RelTranslatedJoin::getFilterCondSize ( ) const

inline

Definition at line 1627 of file RelAlgDag.h.

References filter_ops_.

1627 { return filter_ops_.size(); }

RelTranslatedJoin::filter_ops_

const std::vector< std::shared_ptr< const Analyzer::Expr > > filter_ops_

Definition: RelAlgDag.h:1668

std::vector<const Analyzer::ColumnVar*> RelTranslatedJoin::getJoinCols ( bool lhs ) const

inline

Definition at line 1655 of file RelAlgDag.h.

References lhs_join_cols_, and rhs_join_cols_.

Referenced by QueryPlanDagExtractor::handleTranslatedJoin().

                                                                   {
     if (lhs) {
       return lhs_join_cols_;
     }
     return rhs_join_cols_;
   }

Here is the caller graph for this function:

JoinType RelTranslatedJoin::getJoinType ( ) const

inline

Definition at line 1636 of file RelAlgDag.h.

References join_type_.

1636 { return join_type_; }

RelTranslatedJoin::join_type_

const JoinType join_type_

Definition: RelAlgDag.h:1671

const RelAlgNode* RelTranslatedJoin::getLHS ( ) const

inline

Definition at line 1625 of file RelAlgDag.h.

References lhs_.

Referenced by QueryPlanDagExtractor::handleTranslatedJoin(), and RelRexDagVisitor::visit().

1625 { return lhs_; }

RelTranslatedJoin::lhs_

const RelAlgNode * lhs_

Definition: RelAlgDag.h:1664

Here is the caller graph for this function:

std::string RelTranslatedJoin::getOpType ( ) const

inline

Definition at line 1632 of file RelAlgDag.h.

References op_type_.

1632 { return op_type_; }

RelTranslatedJoin::op_type_

const std::string op_type_

Definition: RelAlgDag.h:1672

std::string RelTranslatedJoin::getOpTypeInfo ( ) const

inline

Definition at line 1634 of file RelAlgDag.h.

References op_typeinfo_.

1634 { return op_typeinfo_; }

RelTranslatedJoin::op_typeinfo_

const std::string op_typeinfo_

Definition: RelAlgDag.h:1674

const RexScalar* RelTranslatedJoin::getOuterJoinCond ( ) const

inline

Definition at line 1631 of file RelAlgDag.h.

References outer_join_cond_.

Referenced by RelRexDagVisitor::visit().

1631 { return outer_join_cond_; }

RelTranslatedJoin::outer_join_cond_

const RexScalar * outer_join_cond_

Definition: RelAlgDag.h:1669

Here is the caller graph for this function:

std::string RelTranslatedJoin::getQualifier ( ) const

inline

Definition at line 1633 of file RelAlgDag.h.

References qualifier_.

1633 { return qualifier_; }

RelTranslatedJoin::qualifier_

const std::string qualifier_

Definition: RelAlgDag.h:1673

const RelAlgNode* RelTranslatedJoin::getRHS ( ) const

inline

Definition at line 1626 of file RelAlgDag.h.

References rhs_.

Referenced by QueryPlanDagExtractor::handleTranslatedJoin(), and RelRexDagVisitor::visit().

1626 { return rhs_; }

RelTranslatedJoin::rhs_

const RelAlgNode * rhs_

Definition: RelAlgDag.h:1665

Here is the caller graph for this function:

bool RelTranslatedJoin::isNestedLoopQual ( ) const

inline

Definition at line 1661 of file RelAlgDag.h.

References nested_loop_.

Referenced by QueryPlanDagExtractor::handleTranslatedJoin().

1661 { return nested_loop_; }

RelTranslatedJoin::nested_loop_

const bool nested_loop_

Definition: RelAlgDag.h:1670

Here is the caller graph for this function:

void RelTranslatedJoin::replaceInput	(	std::shared_ptr< const RelAlgNode >	old_input,
		std::shared_ptr< const RelAlgNode >	input
	)

inlineoverridevirtual

Reimplemented from RelAlgNode.

Definition at line 1646 of file RelAlgDag.h.

References CHECK.

                                                                     {
     CHECK(false);
   }

void RelTranslatedJoin::setCondition ( std::unique_ptr< const RexScalar > & condition )

inline

Definition at line 1645 of file RelAlgDag.h.

References CHECK.

1645 { CHECK(false); }

CHECK

#define CHECK(condition)

Definition: Logger.h:291

size_t RelTranslatedJoin::size ( ) const

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 1635 of file RelAlgDag.h.

1635 { return 0; }

size_t RelTranslatedJoin::toHash ( ) const

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 1608 of file RelAlgDag.h.

References filter_ops_, RelAlgNode::hash_, HASH_N, join_type_, lhs_, nested_loop_, op_type_, op_typeinfo_, outer_join_cond_, qualifier_, RelTranslatedJoin(), rhs_, Rex::toHash(), RelAlgNode::toHash(), and toString().

                                  {
     if (!hash_) {
       hash_ = typeid(RelTranslatedJoin).hash_code();
       boost::hash_combine(*hash_, lhs_->toHash());
       boost::hash_combine(*hash_, rhs_->toHash());
       boost::hash_combine(*hash_, outer_join_cond_ ? outer_join_cond_->toHash() : HASH_N);
       boost::hash_combine(*hash_, nested_loop_);
       boost::hash_combine(*hash_, ::toString(join_type_));
       boost::hash_combine(*hash_, op_type_);
       boost::hash_combine(*hash_, qualifier_);
       boost::hash_combine(*hash_, op_typeinfo_);
       for (auto& filter_op : filter_ops_) {
         boost::hash_combine(*hash_, filter_op->toString());
       }
     }
     return *hash_;
   }

Here is the call graph for this function:

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

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 1585 of file RelAlgDag.h.

References cat(), filter_ops_, join_type_, lhs_join_cols_, nested_loop_, op_type_, op_typeinfo_, outer_join_cond_, qualifier_, rhs_join_cols_, Rex::toString(), and typeName().

Referenced by toHash().

                                                                                    {
     return cat(::typeName(this),
                "( join_quals { lhs: ",
                ::toString(lhs_join_cols_),
                ", rhs: ",
                ::toString(rhs_join_cols_),
                " }, filter_quals: { ",
                ::toString(filter_ops_),
                " }, outer_join_cond: { ",
                outer_join_cond_->toString(config),
                " }, loop_join: ",
                ::toString(nested_loop_),
                ", join_type: ",
                ::toString(join_type_),
                ", op_type: ",
                ::toString(op_type_),
                ", qualifier: ",
                ::toString(qualifier_),
                ", op_type_info: ",
                ::toString(op_typeinfo_),
                ")");
   }