greenplumn CScalar 源码

greenplumn CScalar 代码

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

//---------------------------------------------------------------------------
//	Greenplum Database
//	Copyright (C) 2009 Greenplum, Inc.
//
//	@filename:
//		CScalar.h
//
//	@doc:
//		Base class for all scalar operators
//---------------------------------------------------------------------------
#ifndef GPOPT_CScalar_H
#define GPOPT_CScalar_H

#include "gpos/base.h"

#include "gpopt/base/CDrvdProp.h"
#include "gpopt/base/CPartInfo.h"
#include "gpopt/mdcache/CMDAccessor.h"
#include "gpopt/operators/COperator.h"
#include "naucrates/md/IMDId.h"

namespace gpopt
{
using namespace gpos;
using namespace gpmd;

// forward declaration
class CColRefSet;

//---------------------------------------------------------------------------
//	@class:
//		CScalar
//
//	@doc:
//		base class for all scalar operators
//
//---------------------------------------------------------------------------
class CScalar : public COperator
{
public:
	// possible results of Boolean evaluation of a scalar expression
	enum EBoolEvalResult
	{
		EberTrue = 1,  // TRUE
		EberFalse,	   // FALSE
		EberNull,	   // NULL
		EberNotTrue,   // FALSE or NULL
		EberAny,	   // Any result is possible

		EerSentinel
	};

private:
	// helper for combining partition consumer arrays of scalar children
	static CPartInfo *PpartinfoDeriveCombineScalar(CMemoryPool *mp,
												   CExpressionHandle &exprhdl);

protected:
	// perform conjunction of child boolean evaluation results
	static EBoolEvalResult EberConjunction(ULongPtrArray *pdrgpulChildren);

	// perform disjunction of child boolean evaluation results
	static EBoolEvalResult EberDisjunction(ULongPtrArray *pdrgpulChildren);

	// return Null if any child is Null
	static EBoolEvalResult EberNullOnAnyNullChild(
		ULongPtrArray *pdrgpulChildren);

	// return Null if all children are Null
	static EBoolEvalResult EberNullOnAllNullChildren(
		ULongPtrArray *pdrgpulChildren);

public:
	CScalar(const CScalar &) = delete;

	// ctor
	explicit CScalar(CMemoryPool *mp) : COperator(mp)
	{
	}

	// dtor
	~CScalar() override = default;

	// type of operator
	BOOL
	FScalar() const override
	{
		GPOS_ASSERT(!FPhysical() && !FLogical() && !FPattern());
		return true;
	}

	// create derived properties container
	CDrvdProp *PdpCreate(CMemoryPool *mp) const override;

	// create required properties container
	CReqdProp *PrpCreate(CMemoryPool *mp) const override;

	// return locally defined columns
	virtual CColRefSet *
	PcrsDefined(CMemoryPool *mp,
				CExpressionHandle &	 // exprhdl
	)
	{
		// return an empty set of column refs
		return GPOS_NEW(mp) CColRefSet(mp);
	}

	// return columns containing set-returning function
	virtual CColRefSet *
	PcrsSetReturningFunction(CMemoryPool *mp,
							 CExpressionHandle &  // exprhdl
	)
	{
		// return an empty set of column refs
		return GPOS_NEW(mp) CColRefSet(mp);
	}

	// return locally used columns
	virtual CColRefSet *
	PcrsUsed(CMemoryPool *mp,
			 CExpressionHandle &  // exprhdl
	)
	{
		// return an empty set of column refs
		return GPOS_NEW(mp) CColRefSet(mp);
	}

	// derive partition consumer info
	virtual CPartInfo *
	PpartinfoDerive(CMemoryPool *mp, CExpressionHandle &exprhdl) const
	{
		return PpartinfoDeriveCombineScalar(mp, exprhdl);
	}

	// derive function properties
	virtual CFunctionProp *
	DeriveFunctionProperties(CMemoryPool *mp, CExpressionHandle &exprhdl) const
	{
		return PfpDeriveFromChildren(mp, exprhdl,
									 IMDFunction::EfsImmutable,	 // efdaDefault
									 false,	 // fHasVolatileFunctionScan
									 false	 // fScan
		);
	}

	// derive subquery existence
	virtual BOOL FHasSubquery(CExpressionHandle &exprhdl);

	// derive non-scalar function existence
	virtual BOOL FHasNonScalarFunction(CExpressionHandle &exprhdl);

	virtual BOOL FHasScalarArrayCmp(CExpressionHandle &exprhdl);

	// boolean expression evaluation
	virtual EBoolEvalResult
	Eber(ULongPtrArray *  // pdrgpulChildren
	) const
	{
		// by default, evaluation result can be false, true or NULL
		return EberAny;
	}

	// perform boolean evaluation of the given expression tree
	static EBoolEvalResult EberEvaluate(CMemoryPool *mp,
										CExpression *pexprScalar);

	// conversion function
	static CScalar *
	PopConvert(COperator *pop)
	{
		GPOS_ASSERT(nullptr != pop);
		GPOS_ASSERT(pop->FScalar());

		return dynamic_cast<CScalar *>(pop);
	}

	// the type of the scalar expression
	virtual IMDId *MdidType() const = 0;

	// the type modifier of the scalar expression
	virtual INT
	TypeModifier() const
	{
		return default_type_modifier;
	}

};	// class CScalar

}  // namespace gpopt


#endif	// !GPOPT_CScalar_H

// EOF

相关信息

greenplumn 源码目录

相关文章

greenplumn CExpression 源码

greenplumn CExpressionFactorizer 源码

greenplumn CExpressionHandle 源码

greenplumn CExpressionPreprocessor 源码

greenplumn CExpressionUtils 源码

greenplumn CHashedDistributions 源码

greenplumn CLogical 源码

greenplumn CLogicalApply 源码

greenplumn CLogicalAssert 源码

greenplumn CLogicalBitmapTableGet 源码