greenplumn CPhysical 源码
greenplumn CPhysical 代码
文件路径：/src/backend/gporca/libgpopt/include/gpopt/operators/CPhysical.h
//---------------------------------------------------------------------------
// Greenplum Database
// Copyright (C) 2009 Greenplum, Inc.
//
// @filename:
// CPhysical.h
//
// @doc:
// Base class for all physical operators
//---------------------------------------------------------------------------
#ifndef GPOPT_CPhysical_H
#define GPOPT_CPhysical_H
#include "gpos/base.h"
#include "gpopt/base/CDistributionSpec.h"
#include "gpopt/base/CDistributionSpecSingleton.h"
#include "gpopt/base/CDrvdPropPlan.h"
#include "gpopt/base/CEnfdDistribution.h"
#include "gpopt/base/CEnfdOrder.h"
#include "gpopt/base/CEnfdPartitionPropagation.h"
#include "gpopt/base/CEnfdRewindability.h"
#include "gpopt/base/COrderSpec.h"
#include "gpopt/base/CPartitionPropagationSpec.h"
#include "gpopt/base/CRewindabilitySpec.h"
#include "gpopt/operators/COperator.h"
// number of plan properties requested during optimization, currently, there are 4 properties:
// order, distribution, rewindability and partition propagation
#define GPOPT_PLAN_PROPS 4
namespace gpopt
{
using namespace gpos;
// arrays of unsigned integer arrays
using UlongPtrArray = CDynamicPtrArray<ULONG_PTR, CleanupDeleteArray>;
class CTableDescriptor;
class CCTEMap;
//---------------------------------------------------------------------------
// @class:
// CPhysical
//
// @doc:
// base class for all physical operators
//
//---------------------------------------------------------------------------
class CPhysical : public COperator
{
public:
// the order in which operator triggers the execution of its children
enum EChildExecOrder
{
EceoLeftToRight, // children execute in left to right order
EceoRightToLeft, // children execute in right to left order
EceoSentinel
};
enum EPropogatePartConstraint
{
EppcAllowed,
EppcProhibited,
EppcSentinel
};
private:
//---------------------------------------------------------------------------
// @class:
// CReqdColsRequest
//
// @doc:
// Representation of incoming column requests during optimization
//
//---------------------------------------------------------------------------
class CReqdColsRequest : public CRefCount
{
private:
// incoming required columns
CColRefSet *m_pcrsRequired;
// index of target physical child for which required columns need to be computed
ULONG m_ulChildIndex;
// index of scalar child to be used when computing required columns
ULONG m_ulScalarChildIndex;
public:
CReqdColsRequest(const CReqdColsRequest &) = delete;
// ctor
CReqdColsRequest(CColRefSet *pcrsRequired, ULONG child_index,
ULONG ulScalarChildIndex)
: m_pcrsRequired(pcrsRequired),
m_ulChildIndex(child_index),
m_ulScalarChildIndex(ulScalarChildIndex)
{
GPOS_ASSERT(nullptr != pcrsRequired);
}
// dtor
~CReqdColsRequest() override
{
m_pcrsRequired->Release();
}
// required columns
CColRefSet *
GetColRefSet() const
{
return m_pcrsRequired;
}
// child index to push requirements to
ULONG
UlChildIndex() const
{
return m_ulChildIndex;
}
// scalar child index
ULONG
UlScalarChildIndex() const
{
return m_ulScalarChildIndex;
}
// hash function
static ULONG HashValue(const CReqdColsRequest *prcr);
// equality function
static BOOL Equals(const CReqdColsRequest *prcrFst,
const CReqdColsRequest *prcrSnd);
}; // class CReqdColsRequest
// map of incoming required columns request to computed column sets
using ReqdColsReqToColRefSetMap =
CHashMap<CReqdColsRequest, CColRefSet, CReqdColsRequest::HashValue,
CReqdColsRequest::Equals, CleanupRelease<CReqdColsRequest>,
CleanupRelease<CColRefSet>>;
// hash map of child columns requests
ReqdColsReqToColRefSetMap *m_phmrcr;
// given an optimization context, the elements in this array represent is the
// number of requests that operator will create for its child,
// array entries correspond to order, distribution, rewindability and partition
// propagation, respectively
ULONG m_rgulOptReqs[GPOPT_PLAN_PROPS];
// array of expanded requests
UlongPtrArray *m_pdrgpulpOptReqsExpanded;
// total number of optimization requests
ULONG m_ulTotalOptRequests;
// update number of requests of a given property
void UpdateOptRequests(ULONG ulPropIndex, ULONG ulRequests);
// check whether we can push a part table requirement to a given child, given
// the knowledge of where the part index id is defined
static BOOL FCanPushPartReqToChild(CBitSet *pbsPartConsumer,
ULONG child_index);
protected:
// set number of order requests that operator creates for its child
void
SetOrderRequests(ULONG ulOrderReqs)
{
UpdateOptRequests(0 /*ulPropIndex*/, ulOrderReqs);
}
// set number of distribution requests that operator creates for its child
void
SetDistrRequests(ULONG ulDistrReqs)
{
UpdateOptRequests(1 /*ulPropIndex*/, ulDistrReqs);
}
// set number of rewindability requests that operator creates for its child
void
SetRewindRequests(ULONG ulRewindReqs)
{
UpdateOptRequests(2 /*ulPropIndex*/, ulRewindReqs);
}
// set number of partition propagation requests that operator creates for its child
void
SetPartPropagateRequests(ULONG ulPartPropagationReqs)
{
UpdateOptRequests(3 /*ulPropIndex*/, ulPartPropagationReqs);
}
// pass cte requirement to the n-th child
CCTEReq *PcterNAry(CMemoryPool *mp, CExpressionHandle &exprhdl,
CCTEReq *pcter, ULONG child_index,
CDrvdPropArray *pdrgpdpCtxt) const;
// helper for computing required columns of the n-th child by including used
// columns and excluding defined columns of the scalar child
CColRefSet *PcrsChildReqd(CMemoryPool *mp, CExpressionHandle &exprhdl,
CColRefSet *pcrsInput, ULONG child_index,
ULONG ulScalarIndex);
// helper for a simple case of computing child's required sort order
static COrderSpec *PosPassThru(CMemoryPool *mp, CExpressionHandle &exprhdl,
COrderSpec *posInput, ULONG child_index);
// helper for a simple case of computing child's required distribution
static CDistributionSpec *PdsPassThru(CMemoryPool *mp,
CExpressionHandle &exprhdl,
CDistributionSpec *pdsInput,
ULONG child_index);
// helper for computing child's required distribution when Singleton/Replicated
// distributions must be requested
static CDistributionSpec *PdsRequireSingletonOrReplicated(
CMemoryPool *mp, CExpressionHandle &exprhdl,
CDistributionSpec *pdsInput, ULONG child_index, ULONG ulOptReq);
// helper for computing child's required distribution in unary operators
// with a single scalar child
static CDistributionSpec *PdsUnary(CMemoryPool *mp,
CExpressionHandle &exprhdl,
CDistributionSpec *pdsInput,
ULONG child_index, ULONG ulOptReq);
// helper for a simple case of computing child's required rewindability
static CRewindabilitySpec *PrsPassThru(CMemoryPool *mp,
CExpressionHandle &exprhdl,
CRewindabilitySpec *prsRequired,
ULONG child_index);
// pass cte requirement to the child
static CCTEReq *PcterPushThru(CCTEReq *pcter);
// combine the derived CTE maps of the first n children
// of the given expression handle
static CCTEMap *PcmCombine(CMemoryPool *mp, CDrvdPropArray *pdrgpdpCtxt);
// helper for common case of sort order derivation
static COrderSpec *PosDerivePassThruOuter(CExpressionHandle &exprhdl);
// helper for common case of distribution derivation
static CDistributionSpec *PdsDerivePassThruOuter(
CExpressionHandle &exprhdl);
// helper for common case of rewindability derivation
static CRewindabilitySpec *PrsDerivePassThruOuter(
CMemoryPool *mp, CExpressionHandle &exprhdl);
// helper for checking if output columns of a unary operator
// that defines no new columns include the required columns
static BOOL FUnaryProvidesReqdCols(CExpressionHandle &exprhdl,
CColRefSet *pcrsRequired);
// Generate a singleton distribution spec request
static CDistributionSpec *PdsRequireSingleton(CMemoryPool *mp,
CExpressionHandle &exprhdl,
CDistributionSpec *pds,
ULONG child_index);
// helper to compute skew estimate based on given stats and distribution spec
static CDouble GetSkew(IStatistics *stats, CDistributionSpec *pds);
// return true if the given column set includes any of the columns defined by
// the unary node, as given by the handle
static BOOL FUnaryUsesDefinedColumns(CColRefSet *pcrs,
CExpressionHandle &exprhdl);
// compute required distribution of the n-th child
virtual CDistributionSpec *PdsRequired(CMemoryPool *mp,
CExpressionHandle &exprhdl,
CDistributionSpec *pdsRequired,
ULONG child_index,
CDrvdPropArray *pdrgpdpCtxt,
ULONG ulOptReq) const = 0;
// distribution matching type
virtual CEnfdDistribution::EDistributionMatching Edm(
CReqdPropPlan *prppInput, ULONG child_index,
CDrvdPropArray *pdrgpdpCtxt, ULONG ulOptReq);
public:
CPhysical(const CPhysical &) = delete;
// ctor
explicit CPhysical(CMemoryPool *mp);
// dtor
~CPhysical() override
{
CRefCount::SafeRelease(m_phmrcr);
CRefCount::SafeRelease(m_pdrgpulpOptReqsExpanded);
}
// type of operator
BOOL
FPhysical() const override
{
GPOS_ASSERT(!FLogical() && !FScalar() && !FPattern());
return true;
}
// create base container of derived properties
CDrvdProp *PdpCreate(CMemoryPool *mp) const override;
// create base container of required properties
CReqdProp *PrpCreate(CMemoryPool *mp) const override;
//-------------------------------------------------------------------------------------
// Required Plan Properties
//-------------------------------------------------------------------------------------
// compute required output columns of the n-th child
virtual CColRefSet *PcrsRequired(
CMemoryPool *mp, CExpressionHandle &exprhdl, CColRefSet *pcrsRequired,
ULONG child_index, CDrvdPropArray *pdrgpdpCtxt, ULONG ulOptReq) = 0;
// compute required ctes of the n-th child
virtual CCTEReq *PcteRequired(CMemoryPool *mp, CExpressionHandle &exprhdl,
CCTEReq *pcter, ULONG child_index,
CDrvdPropArray *pdrgpdpCtxt,
ULONG ulOptReq) const = 0;
// compute distribution spec from the table descriptor
static CDistributionSpec *PdsCompute(CMemoryPool *mp,
const CTableDescriptor *ptabdesc,
CColRefArray *pdrgpcrOutput,
CColRef *gp_segment_id);
// compute required sort order of the n-th child
virtual COrderSpec *PosRequired(CMemoryPool *mp, CExpressionHandle &exprhdl,
COrderSpec *posRequired, ULONG child_index,
CDrvdPropArray *pdrgpdpCtxt,
ULONG ulOptReq) const = 0;
// compute required rewindability of the n-th child
virtual CRewindabilitySpec *PrsRequired(CMemoryPool *mp,
CExpressionHandle &exprhdl,
CRewindabilitySpec *prsRequired,
ULONG child_index,
CDrvdPropArray *pdrgpdpCtxt,
ULONG ulOptReq) const = 0;
// compute required partition propoagation spec of the n-th child
virtual CPartitionPropagationSpec *PppsRequired(
CMemoryPool *mp, CExpressionHandle &exprhdl,
CPartitionPropagationSpec *pppsRequired, ULONG child_index,
CDrvdPropArray *pdrgpdpCtxt, ULONG ulOptReq) const;
// required properties: check if required columns are included in output columns
virtual BOOL FProvidesReqdCols(CExpressionHandle &exprhdl,
CColRefSet *pcrsRequired,
ULONG ulOptReq) const = 0;
// required properties: check if required CTEs are included in derived CTE map
virtual BOOL FProvidesReqdCTEs(CExpressionHandle &exprhdl,
const CCTEReq *pcter) const;
//-------------------------------------------------------------------------------------
// Derived Plan Properties
//-------------------------------------------------------------------------------------
// derive sort order
virtual COrderSpec *PosDerive(CMemoryPool *mp,
CExpressionHandle &exprhdl) const = 0;
// dderive distribution
virtual CDistributionSpec *PdsDerive(CMemoryPool *mp,
CExpressionHandle &exprhdl) const = 0;
// derived properties: derive rewindability
virtual CRewindabilitySpec *PrsDerive(CMemoryPool *mp,
CExpressionHandle &exprhdl) const = 0;
// derived properties: derive partition propagation spec
virtual CPartitionPropagationSpec *PppsDerive(
CMemoryPool *mp, CExpressionHandle &exprhdl) const;
// derive cte map
virtual CCTEMap *PcmDerive(CMemoryPool *mp,
CExpressionHandle &exprhdl) const;
//-------------------------------------------------------------------------------------
// Enforced Properties
// See CEngine::FCheckEnfdProps() for comments on usage.
//-------------------------------------------------------------------------------------
// return order property enforcing type for this operator
virtual CEnfdProp::EPropEnforcingType EpetOrder(
CExpressionHandle &exprhdl, const CEnfdOrder *peo) const = 0;
// return distribution property enforcing type for this operator
virtual CEnfdProp::EPropEnforcingType EpetDistribution(
CExpressionHandle &exprhdl, const CEnfdDistribution *ped) const;
// return rewindability property enforcing type for this operator
virtual CEnfdProp::EPropEnforcingType EpetRewindability(
CExpressionHandle &exprhdl, const CEnfdRewindability *per) const = 0;
// return partition propagation property enforcing type for this operator
virtual CEnfdProp::EPropEnforcingType EpetPartitionPropagation(
CExpressionHandle &exprhdl, const CEnfdPartitionPropagation *per) const;
// order matching type
virtual CEnfdOrder::EOrderMatching Eom(CReqdPropPlan *prppInput,
ULONG child_index,
CDrvdPropArray *pdrgpdpCtxt,
ULONG ulOptReq);
// rewindability matching type
virtual CEnfdRewindability::ERewindabilityMatching Erm(
CReqdPropPlan *prppInput, ULONG child_index,
CDrvdPropArray *pdrgpdpCtxt, ULONG ulOptReq);
// check if optimization contexts is valid
virtual BOOL
FValidContext(CMemoryPool *, // mp
COptimizationContext *, // poc,
COptimizationContextArray * // pdrgpocChild
) const
{
return true;
}
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
// execution order of children
virtual EChildExecOrder
Eceo() const
{
// by default, children execute in left to right order
return EceoLeftToRight;
}
// number of order requests that operator creates for its child
ULONG
UlOrderRequests() const
{
return m_rgulOptReqs[0];
}
// number of distribution requests that operator creates for its child
ULONG
UlDistrRequests() const
{
return m_rgulOptReqs[1];
}
// number of rewindability requests that operator creates for its child
ULONG
UlRewindRequests() const
{
return m_rgulOptReqs[2];
}
// number of partition propagation requests that operator creates for its child
ULONG
UlPartPropagateRequests() const
{
return m_rgulOptReqs[3];
}
// return total number of optimization requests
ULONG
UlOptRequests() const
{
return m_ulTotalOptRequests;
}
// map request number to order, distribution, rewindability and partition propagation requests
void LookupRequest(
ULONG ulReqNo, // input: request number
ULONG *pulOrderReq, // output: order request number
ULONG *pulDistrReq, // output: distribution request number
ULONG *pulRewindReq, // output: rewindability request number
ULONG *
pulPartPropagateReq // output: partition propagation request number
);
// return true if operator passes through stats obtained from children,
// this is used when computing stats during costing
virtual BOOL FPassThruStats() const = 0;
// true iff the delivered distributions of the children are compatible among themselves
virtual BOOL FCompatibleChildrenDistributions(
const CExpressionHandle &exprhdl) const;
// return a copy of the operator with remapped columns
COperator *PopCopyWithRemappedColumns(CMemoryPool *mp,
UlongToColRefMap *colref_mapping,
BOOL must_exist) override;
// conversion function
static CPhysical *
PopConvert(COperator *pop)
{
GPOS_ASSERT(nullptr != pop);
GPOS_ASSERT(pop->FPhysical());
return dynamic_cast<CPhysical *>(pop);
}
// helper for computing a singleton distribution matching the given distribution
static CDistributionSpecSingleton *PdssMatching(
CMemoryPool *mp, CDistributionSpecSingleton *pdss);
virtual CEnfdDistribution *Ped(CMemoryPool *mp, CExpressionHandle &exprhdl,
CReqdPropPlan *prppInput, ULONG child_index,
CDrvdPropArray *pdrgpdpCtxt,
ULONG ulDistrReq);
}; // class CPhysical
} // namespace gpopt
#endif // !GPOPT_CPhysical_H
// EOF
相关信息
相关文章
greenplumn CExpressionFactorizer 源码
greenplumn CExpressionHandle 源码
greenplumn CExpressionPreprocessor 源码
greenplumn CExpressionUtils 源码
0
赞
热门推荐
-
2、 - 优质文章
-
3、 gate.io
-
7、 golang
-
9、 openharmony
-
10、 Vue中input框自动聚焦