greenplumn CExpression 源码

greenplumn CExpression 代码

文件路径：/src/backend/gporca/libgpopt/include/gpopt/operators/CExpression.h

//---------------------------------------------------------------------------
//	Greenplum Database
//	Copyright (C) 2009 - 2011 EMC CORP.
//
//	@filename:
//		CExpression.h
//
//	@doc:
//		Basic tree/DAG-based representation for an expression
//---------------------------------------------------------------------------
#ifndef GPOPT_CExpression_H
#define GPOPT_CExpression_H

#include "gpos/base.h"
#include "gpos/common/CDynamicPtrArray.h"
#include "gpos/common/CRefCount.h"
#include "gpos/common/DbgPrintMixin.h"

#include "gpopt/base/CColRef.h"
#include "gpopt/base/CCostContext.h"
#include "gpopt/base/CDrvdPropRelational.h"
#include "gpopt/base/CDrvdPropScalar.h"
#include "gpopt/base/CKeyCollection.h"
#include "gpopt/base/CPrintPrefix.h"
#include "gpopt/base/CReqdProp.h"
#include "gpopt/base/CReqdPropRelational.h"
#include "gpopt/cost/CCost.h"
#include "gpopt/operators/COperator.h"
#include "naucrates/statistics/IStatistics.h"

namespace gpopt
{
// cleanup function for arrays
class CExpression;
using CExpressionArray = CDynamicPtrArray<CExpression, CleanupRelease>;

// array of arrays of expression pointers
using CExpressionArrays = CDynamicPtrArray<CExpressionArray, CleanupRelease>;

class CGroupExpression;
class CDrvdPropPlan;
class CDrvdPropCtxt;
class CDrvdPropCtxtPlan;
class CPropConstraint;

using namespace gpos;
using namespace gpnaucrates;

//---------------------------------------------------------------------------
//	@class:
//		CExpression
//
//	@doc:
//		Simply dynamic array for pointer types
//
//---------------------------------------------------------------------------
class CExpression : public CRefCount, public gpos::DbgPrintMixin<CExpression>
{
	friend class CExpressionHandle;

private:
	// memory pool
	CMemoryPool *m_mp;

	// operator class
	COperator *m_pop;

	// array of children
	CExpressionArray *m_pdrgpexpr;

	// derived relational properties
	CDrvdPropRelational *m_pdprel;

	// derived stats
	IStatistics *m_pstats;

	// required plan properties
	CReqdPropPlan *m_prpp;

	// derived physical properties
	CDrvdPropPlan *m_pdpplan;

	// derived scalar properties
	CDrvdPropScalar *m_pdpscalar;

	// group reference to Memo
	CGroupExpression *m_pgexpr;

	// cost of physical expression node when copied out of the memo
	CCost m_cost;

	// id of origin group, used for debugging expressions extracted from memo
	ULONG m_ulOriginGrpId;

	// id of origin group expression, used for debugging expressions extracted from memo
	ULONG m_ulOriginGrpExprId;

	// get expression's derived property given its type
	CDrvdProp *Pdp(const CDrvdProp::EPropType ept) const;

#ifdef GPOS_DEBUG

	// assert valid property derivation
	void AssertValidPropDerivation(const CDrvdProp::EPropType ept);

	// print expression properties
	void PrintProperties(IOstream &os, CPrintPrefix &pfx) const;

#endif	// GPOS_DEBUG

#if 0
	// check if the expression satisfies partition enforcer condition
	BOOL FValidPartEnforcers(CDrvdPropCtxtPlan *pdpctxtplan);
#endif

	// check if the distributions of all children are compatible
	BOOL FValidChildrenDistribution(CDrvdPropCtxtPlan *pdpctxtplan);

	// copy group properties and stats to expression
	void CopyGroupPropsAndStats(IStatistics *input_stats);

public:
	CExpression(const CExpression &) = delete;

	// ctor's with different arity

	// ctor for leaf nodes
	CExpression(CMemoryPool *mp, COperator *pop,
				CGroupExpression *pgexpr = nullptr);

	// ctor for unary expressions
	CExpression(CMemoryPool *mp, COperator *pop, CExpression *pexpr);

	// ctor for binary expressions
	CExpression(CMemoryPool *mp, COperator *pop, CExpression *pexprChildFirst,
				CExpression *pexprChildSecond);

	// ctor for ternary expressions
	CExpression(CMemoryPool *mp, COperator *pop, CExpression *pexprChildFirst,
				CExpression *pexprChildSecond, CExpression *pexprChildThird);

	// ctor n-ary expressions
	CExpression(CMemoryPool *mp, COperator *pop, CExpressionArray *pdrgpexpr);

	// ctor for n-ary expression with origin group expression
	CExpression(CMemoryPool *mp, COperator *pop, CGroupExpression *pgexpr,
				CExpressionArray *pdrgpexpr, CReqdPropPlan *prpp,
				IStatistics *input_stats, CCost cost = GPOPT_INVALID_COST);

	// dtor
	~CExpression() override;

	// shorthand to access children
	CExpression *
	operator[](ULONG ulPos) const
	{
		GPOS_ASSERT(nullptr != m_pdrgpexpr);
		return (*m_pdrgpexpr)[ulPos];
	};

	// arity function
	ULONG
	Arity() const
	{
		return m_pdrgpexpr == nullptr ? 0 : m_pdrgpexpr->Size();
	}

	// accessor for operator
	COperator *
	Pop() const
	{
		GPOS_ASSERT(nullptr != m_pop);
		return m_pop;
	}

	// accessor of children array
	CExpressionArray *
	PdrgPexpr() const
	{
		return m_pdrgpexpr;
	}

	// accessor for origin group expression
	CGroupExpression *
	Pgexpr() const
	{
		return m_pgexpr;
	}

	// accessor for computed required plan props
	CReqdPropPlan *
	Prpp() const
	{
		return m_prpp;
	}

	CDrvdPropRelational *GetDrvdPropRelational() const;

	CDrvdPropPlan *GetDrvdPropPlan() const;

	CDrvdPropScalar *GetDrvdPropScalar() const;

	// get derived statistics object
	const IStatistics *
	Pstats() const
	{
		return m_pstats;
	}

	// cost accessor
	CCost
	Cost() const
	{
		return m_cost;
	}

	// get the suitable derived property type based on operator
	CDrvdProp::EPropType Ept() const;

	// Derive all properties immediately. The suitable derived property is
	// determined internally. To derive properties on an on-demand bases, use
	// DeriveXXX() methods.
	CDrvdProp *PdpDerive(CDrvdPropCtxt *pdpctxt = nullptr);

	// derive statistics
	IStatistics *PstatsDerive(CReqdPropRelational *prprel,
							  IStatisticsArray *stats_ctxt);

	// reset a derived property
	void ResetDerivedProperty(CDrvdProp::EPropType ept);

	// reset all derived properties
	void ResetDerivedProperties();

	// reset expression stats
	void ResetStats();

	// check for outer references
	BOOL HasOuterRefs();

	// print driver
	IOstream &OsPrint(IOstream &os) const;

	// print driver, customized for expressions
	IOstream &OsPrintExpression(IOstream &os, const CPrintPrefix * = nullptr,
								BOOL fLast = true) const;

	// match with group expression
	BOOL FMatchPattern(CGroupExpression *pgexpr) const;

	// return a copy of the expression with remapped columns
	CExpression *PexprCopyWithRemappedColumns(CMemoryPool *mp,
											  UlongToColRefMap *colref_mapping,
											  BOOL must_exist) const;

	// compare entire expression rooted here
	BOOL Matches(CExpression *pexpr) const;

#ifdef GPOS_DEBUG
	// match against given pattern
	BOOL FMatchPattern(CExpression *pexpr) const;

	// match children against given pattern
	BOOL FMatchPatternChildren(CExpression *pexpr) const;

	// compare entire expression rooted here
	BOOL FMatchDebug(CExpression *pexpr) const;

	// debug print; for interactive debugging sessions only
	// prints expression properties as well
	void DbgPrintWithProperties() const;
#endif	// GPOS_DEBUG

	// check if the expression satisfies given required properties
	BOOL FValidPlan(const CReqdPropPlan *prpp, CDrvdPropCtxtPlan *pdpctxtplan);

	// static hash function
	static ULONG HashValue(const CExpression *pexpr);

	// static hash function
	static ULONG UlHashDedup(const CExpression *pexpr);

	// rehydrate expression from a given cost context and child expressions
	static CExpression *PexprRehydrate(CMemoryPool *mp, CCostContext *pcc,
									   CExpressionArray *pdrgpexpr,
									   CDrvdPropCtxtPlan *pdpctxtplan);

	// Relational property accessors - derived as needed
	CColRefSet *DeriveOuterReferences();
	CColRefSet *DeriveOutputColumns();
	CColRefSet *DeriveNotNullColumns();
	CColRefSet *DeriveCorrelatedApplyColumns();
	CKeyCollection *DeriveKeyCollection();
	CPropConstraint *DerivePropertyConstraint();
	CMaxCard DeriveMaxCard();
	ULONG DeriveJoinDepth();
	CFunctionProp *DeriveFunctionProperties();
	CFunctionalDependencyArray *DeriveFunctionalDependencies();
	CPartInfo *DerivePartitionInfo();
	CTableDescriptor *DeriveTableDescriptor();

	// Scalar property accessors - derived as needed
	CColRefSet *DeriveDefinedColumns();
	CColRefSet *DeriveUsedColumns();
	CColRefSet *DeriveSetReturningFunctionColumns();
	BOOL DeriveHasSubquery();
	CPartInfo *DeriveScalarPartitionInfo();
	CFunctionProp *DeriveScalarFunctionProperties();
	BOOL DeriveHasNonScalarFunction();
	ULONG DeriveTotalDistinctAggs();
	BOOL DeriveHasMultipleDistinctAggs();
	BOOL DeriveHasScalarArrayCmp();
	BOOL DeriveHasScalarFuncProject();
	ULONG DeriveTotalOrderedAggs();

};	// class CExpression


// shorthand for printing
inline IOstream &
operator<<(IOstream &os, CExpression &expr)
{
	return expr.OsPrint(os);
}

// hash map from ULONG to expression
using UlongToExprMap =
	CHashMap<ULONG, CExpression, gpos::HashValue<ULONG>, gpos::Equals<ULONG>,
			 CleanupDelete<ULONG>, CleanupRelease<CExpression>>;

// map iterator
using UlongToExprMapIter =
	CHashMapIter<ULONG, CExpression, gpos::HashValue<ULONG>,
				 gpos::Equals<ULONG>, CleanupDelete<ULONG>,
				 CleanupRelease<CExpression>>;

}  // namespace gpopt


#endif	// !GPOPT_CExpression_H

// EOF

相关信息

greenplumn 源码目录

相关文章

greenplumn CExpressionFactorizer 源码

greenplumn CExpressionHandle 源码

greenplumn CExpressionPreprocessor 源码

greenplumn CExpressionUtils 源码

greenplumn CHashedDistributions 源码

greenplumn CLogical 源码

greenplumn CLogicalApply 源码

greenplumn CLogicalAssert 源码

greenplumn CLogicalBitmapTableGet 源码

greenplumn CLogicalCTEAnchor 源码