#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)

virtual void	acceptChildren (Visitor &v) const override

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

std::string	toString (RelRexToStringConfig config=RelRexToStringConfig::defaults()) 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

virtual size_t	toHash () const override

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

bool	hasContextData () const

const RaExecutionDesc *	getContextData () const

const size_t	inputCount () const

const RelAlgNode *	getInput (const size_t idx) const

const std::vector< RelAlgNode const * >	getInputs () 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

Public Member Functions inherited from RelAlgDagNode
	RelAlgDagNode ()

virtual size_t	getStepNumber () const

virtual void	setStepNumber (size_t step) const

std::optional< size_t >	getIdInPlanTree () const

void	setIdInPlanTree (size_t id) 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_

Friends
std::size_t	hash_value (RelTranslatedJoin const &)

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 >	hash_

Protected Attributes inherited from RelAlgDagNode
size_t	step_ {0}

std::optional< size_t >	id_in_plan_tree_

Detailed Description

Definition at line 1741 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 1743 of file RelAlgDag.h.

       : 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) {}

Member Function Documentation

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

inlineoverridevirtual

Implements RelAlgDagNode.

Definition at line 1782 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 RelTranslatedJoin::acceptChildren ( Visitor & v ) const

inlineoverridevirtual

Implements RelAlgDagNode.

Definition at line 1766 of file RelAlgDag.h.

References RelAlgDagNode::accept(), RelAlgNode::getInputs(), getLHS(), getOuterJoinCond(), getRHS(), and anonymous_namespace{Utm.h}::n.

Referenced by accept().

                                                          {
     if (getLHS()) {
       getLHS()->accept(v, "left");
     }
     if (getRHS()) {
       getRHS()->accept(v, "right");
     }
     if (getOuterJoinCond()) {
       getOuterJoinCond()->accept(v, "outer condition");
     }
     for (auto& n : getInputs()) {
       if (n) {
         n->accept(v, "input");
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 1832 of file RelAlgDag.h.

References CHECK.

                                                       {
     CHECK(false);
     return nullptr;
   }

const RexScalar* RelTranslatedJoin::getAndReleaseCondition ( ) const

inline

Definition at line 1823 of file RelAlgDag.h.

References CHECK.

                                                   {
     CHECK(false);
     return nullptr;
   }

const RexScalar* RelTranslatedJoin::getCondition ( ) const

inline

Definition at line 1819 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 1810 of file RelAlgDag.h.

References filter_ops_.

                                                                            {
     return filter_ops_;
   }

size_t RelTranslatedJoin::getFilterCondSize ( ) const

inline

Definition at line 1809 of file RelAlgDag.h.

References filter_ops_.

1809 { return filter_ops_.size(); }

RelTranslatedJoin::filter_ops_

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

Definition: RelAlgDag.h:1854

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

inline

Definition at line 1837 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 1818 of file RelAlgDag.h.

References join_type_.

1818 { return join_type_; }

RelTranslatedJoin::join_type_

const JoinType join_type_

Definition: RelAlgDag.h:1857

const RelAlgNode* RelTranslatedJoin::getLHS ( ) const

inline

Definition at line 1807 of file RelAlgDag.h.

References lhs_.

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

1807 { return lhs_; }

RelTranslatedJoin::lhs_

const RelAlgNode * lhs_

Definition: RelAlgDag.h:1850

Here is the caller graph for this function:

std::string RelTranslatedJoin::getOpType ( ) const

inline

Definition at line 1814 of file RelAlgDag.h.

References op_type_.

1814 { return op_type_; }

RelTranslatedJoin::op_type_

const std::string op_type_

Definition: RelAlgDag.h:1858

std::string RelTranslatedJoin::getOpTypeInfo ( ) const

inline

Definition at line 1816 of file RelAlgDag.h.

References op_typeinfo_.

1816 { return op_typeinfo_; }

RelTranslatedJoin::op_typeinfo_

const std::string op_typeinfo_

Definition: RelAlgDag.h:1860

const RexScalar* RelTranslatedJoin::getOuterJoinCond ( ) const

inline

Definition at line 1813 of file RelAlgDag.h.

References outer_join_cond_.

Referenced by acceptChildren(), and RelRexDagVisitor::visit().

1813 { return outer_join_cond_; }

RelTranslatedJoin::outer_join_cond_

const RexScalar * outer_join_cond_

Definition: RelAlgDag.h:1855

Here is the caller graph for this function:

std::string RelTranslatedJoin::getQualifier ( ) const

inline

Definition at line 1815 of file RelAlgDag.h.

References qualifier_.

1815 { return qualifier_; }

RelTranslatedJoin::qualifier_

const std::string qualifier_

Definition: RelAlgDag.h:1859

const RelAlgNode* RelTranslatedJoin::getRHS ( ) const

inline

Definition at line 1808 of file RelAlgDag.h.

References rhs_.

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

1808 { return rhs_; }

RelTranslatedJoin::rhs_

const RelAlgNode * rhs_

Definition: RelAlgDag.h:1851

Here is the caller graph for this function:

bool RelTranslatedJoin::isNestedLoopQual ( ) const

inline

Definition at line 1843 of file RelAlgDag.h.

References nested_loop_.

Referenced by QueryPlanDagExtractor::handleTranslatedJoin().

1843 { return nested_loop_; }

RelTranslatedJoin::nested_loop_

const bool nested_loop_

Definition: RelAlgDag.h:1856

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 1828 of file RelAlgDag.h.

References CHECK.

                                                                     {
     CHECK(false);
   }

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

inline

Definition at line 1827 of file RelAlgDag.h.

References CHECK.

1827 { CHECK(false); }

CHECK

#define CHECK(condition)

Definition: Logger.h:291

size_t RelTranslatedJoin::size ( ) const

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 1817 of file RelAlgDag.h.

1817 { return 0; }

virtual size_t RelTranslatedJoin::toHash ( ) const

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 1845 of file RelAlgDag.h.

References hash_value.

1845 { return hash_value(*this); }

RelTranslatedJoin::hash_value

friend std::size_t hash_value(RelTranslatedJoin const &)

Definition: RelAlgDag.cpp:3736

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

inlineoverridevirtual

Implements RelAlgNode.

Definition at line 1788 of file RelAlgDag.h.

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

                                                                                    {
     std::ostringstream oss;
     oss << ::typeName(this) << "( join_quals { lhs: " << ::toString(lhs_join_cols_);
     oss << "rhs: " << ::toString(rhs_join_cols_);
     oss << " }, filter_quals: { " << ::toString(filter_ops_);
     oss << " }, outer_join_cond: { ";
     if (outer_join_cond_) {
       oss << outer_join_cond_->toString(config);
     } else {
       oss << "N/A";
     }
     oss << " }, loop_join: " << ::toString(nested_loop_);
     oss << ", join_type: " << ::toString(join_type_);
     oss << ", op_type: " << ::toString(op_type_);
     oss << ", qualifier: " << ::toString(qualifier_);
     oss << ", op_type_info: " << ::toString(op_typeinfo_) << ")";
     return oss.str();
   }

Here is the call graph for this function:

Friends And Related Function Documentation

std::size_t hash_value ( RelTranslatedJoin const & rel_tr_join )

friend

Definition at line 3736 of file RelAlgDag.cpp.

Referenced by toHash().

                                                            {
   if (rel_tr_join.hash_) {
     return *rel_tr_join.hash_;
   }
   rel_tr_join.hash_ = typeid(RelTranslatedJoin).hash_code();
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.lhs_);
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.rhs_);
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.outer_join_cond_);
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.nested_loop_);
   boost::hash_combine(*rel_tr_join.hash_, ::toString(rel_tr_join.join_type_));
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.op_type_);
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.qualifier_);
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.op_typeinfo_);
   boost::hash_combine(*rel_tr_join.hash_, rel_tr_join.filter_ops_);
   return *rel_tr_join.hash_;
 }