greenplumn CPhysicalAssert 代码
文件路径：/src/backend/gporca/libgpopt/src/operators/CPhysicalAssert.cpp
/---------------------------------------------------------------------------
/ Greenplum Database
/ Copyright (C) 2012 EMC Corp.
/
/ @filename:
/ CPhysicalAssert.cpp
/
/ @doc:
/ Implementation of assert operator
/---------------------------------------------------------------------------
#include "gpopt/operators/CPhysicalAssert.h"
#include "gpos/base.h"
#include "gpopt/base/CRewindabilitySpec.h"
#include "gpopt/operators/CExpressionHandle.h"
#include "gpopt/operators/CPredicateUtils.h"
using namespace gpopt;
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::CPhysicalAssert
/
/ @doc:
/ Ctor
/
/---------------------------------------------------------------------------
CPhysicalAssert::CPhysicalAssert(CMemoryPool *mp, CException *pexc)
: CPhysical(mp), m_pexc(pexc)
{
GPOS_ASSERT(nullptr != pexc);
/ when Assert includes outer references, correlated execution has to be enforced,
/ in this case, we create two optimization requests to guarantee correct evaluation of parameters
/ (1) Broadcast
/ (2) Singleton
SetDistrRequests(2);
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::~CPhysicalAssert
/
/ @doc:
/ Dtor
/
/---------------------------------------------------------------------------
CPhysicalAssert::~CPhysicalAssert()
{
GPOS_DELETE(m_pexc);
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::PcrsRequired
/
/ @doc:
/ Compute required output columns of the n-th child
/
/---------------------------------------------------------------------------
CColRefSet *
CPhysicalAssert::PcrsRequired(CMemoryPool *mp, CExpressionHandle &exprhdl,
CColRefSet *pcrsRequired, ULONG child_index,
CDrvdPropArray *, / pdrgpdpCtxt
ULONG / ulOptReq
)
{
GPOS_ASSERT(
0 == child_index &&
"Required properties can only be computed on the relational child");
return PcrsChildReqd(mp, exprhdl, pcrsRequired, child_index,
1 /*ulScalarIndex*/);
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::PosRequired
/
/ @doc:
/ Compute required sort order of the n-th child
/
/---------------------------------------------------------------------------
COrderSpec *
CPhysicalAssert::PosRequired(CMemoryPool *mp, CExpressionHandle &exprhdl,
COrderSpec *posRequired, ULONG child_index,
CDrvdPropArray *, / pdrgpdpCtxt
ULONG / ulOptReq
) const
{
GPOS_ASSERT(0 == child_index);
return PosPassThru(mp, exprhdl, posRequired, child_index);
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::PdsRequired
/
/ @doc:
/ Compute required distribution of the n-th child
/
/---------------------------------------------------------------------------
CDistributionSpec *
CPhysicalAssert::PdsRequired(CMemoryPool *mp, CExpressionHandle &exprhdl,
CDistributionSpec *pdsRequired, ULONG child_index,
CDrvdPropArray *, / pdrgpdpCtxt
ULONG ulOptReq) const
{
CDistributionSpec::EDistributionType edt = pdsRequired->Edt();
/ pass through singleton and broadcast requests
if (CDistributionSpec::EdtSingleton == edt ||
CDistributionSpec::EdtStrictSingleton == edt ||
CDistributionSpec::EdtReplicated == edt ||
CDistributionSpec::EdtStrictReplicated == edt)
{
pdsRequired->AddRef();
return pdsRequired;
}
return CPhysical::PdsUnary(mp, exprhdl, pdsRequired, child_index, ulOptReq);
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::PrsRequired
/
/ @doc:
/ Compute required rewindability of the n-th child
/
/---------------------------------------------------------------------------
CRewindabilitySpec *
CPhysicalAssert::PrsRequired(CMemoryPool *mp, CExpressionHandle &exprhdl,
CRewindabilitySpec *prsRequired, ULONG child_index,
CDrvdPropArray *, / pdrgpdpCtxt
ULONG / ulOptReq
) const
{
GPOS_ASSERT(0 == child_index);
return PrsPassThru(mp, exprhdl, prsRequired, child_index);
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::PcteRequired
/
/ @doc:
/ Compute required CTE map of the n-th child
/
/---------------------------------------------------------------------------
CCTEReq *
CPhysicalAssert::PcteRequired(CMemoryPool *, /mp,
CExpressionHandle &, /exprhdl,
CCTEReq *pcter,
ULONG
#ifdef GPOS_DEBUG
child_index
#endif
,
CDrvdPropArray *, /pdrgpdpCtxt,
ULONG /ulOptReq
) const
{
GPOS_ASSERT(0 == child_index);
return PcterPushThru(pcter);
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::PosDerive
/
/ @doc:
/ Derive sort order
/
/---------------------------------------------------------------------------
COrderSpec *
CPhysicalAssert::PosDerive(CMemoryPool *, / mp
CExpressionHandle &exprhdl) const
{
return PosDerivePassThruOuter(exprhdl);
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::PdsDerive
/
/ @doc:
/ Derive distribution
/
/---------------------------------------------------------------------------
CDistributionSpec *
CPhysicalAssert::PdsDerive(CMemoryPool *, / mp
CExpressionHandle &exprhdl) const
{
return PdsDerivePassThruOuter(exprhdl);
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::PrsDerive
/
/ @doc:
/ Derive rewindability
/
/---------------------------------------------------------------------------
CRewindabilitySpec *
CPhysicalAssert::PrsDerive(CMemoryPool *mp, CExpressionHandle &exprhdl) const
{
return PrsDerivePassThruOuter(mp, exprhdl);
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::Matches
/
/ @doc:
/ Match operators
/
/---------------------------------------------------------------------------
BOOL
CPhysicalAssert::Matches(COperator *pop) const
{
if (Eopid() != pop->Eopid())
{
return false;
}
CPhysicalAssert *popAssert = CPhysicalAssert::PopConvert(pop);
return CException::Equals(*(popAssert->Pexc()), *m_pexc);
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::FProvidesReqdCols
/
/ @doc:
/ Check if required columns are included in output columns
/
/---------------------------------------------------------------------------
BOOL
CPhysicalAssert::FProvidesReqdCols(CExpressionHandle &exprhdl,
CColRefSet *pcrsRequired,
ULONG / ulOptReq
) const
{
return FUnaryProvidesReqdCols(exprhdl, pcrsRequired);
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::EpetOrder
/
/ @doc:
/ Return the enforcing type for order property based on this operator
/
/---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalAssert::EpetOrder(CExpressionHandle &, / exprhdl
const CEnfdOrder *
#ifdef GPOS_DEBUG
peo
#endif / GPOS_DEBUG
) const
{
GPOS_ASSERT(nullptr != peo);
GPOS_ASSERT(!peo->PosRequired()->IsEmpty());
/ always force sort to be on top of assert
return CEnfdProp::EpetRequired;
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::EpetRewindability
/
/ @doc:
/ Return the enforcing type for rewindability property based on this operator
/
/---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalAssert::EpetRewindability(CExpressionHandle &exprhdl,
const CEnfdRewindability *per) const
{
/ get rewindability delivered by the assert node
CRewindabilitySpec *prs = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Prs();
if (per->FCompatible(prs))
{
/ required rewindability is already provided
return CEnfdProp::EpetUnnecessary;
}
/ always force spool to be on top of assert
return CEnfdProp::EpetRequired;
}
/---------------------------------------------------------------------------
/ @function:
/ CPhysicalAssert::OsPrint
/
/ @doc:
/ Debug print
/
/---------------------------------------------------------------------------
IOstream &
CPhysicalAssert::OsPrint(IOstream &os) const
{
if (m_fPattern)
{
return COperator::OsPrint(os);
}
os << SzId() << " (Error code: " << m_pexc->GetSQLState() << ")";
return os;
}
/ EOF
相关信息
相关文章
greenplumn CExpressionFactorizer 源码
greenplumn CExpressionHandle 源码
greenplumn CExpressionPreprocessor 源码
greenplumn CExpressionUtils 源码