//---------------------------------------------------------------------------
// @function:
// CLogicalAssert::Maxcard
//
// @doc:
// Derive max card
//
//---------------------------------------------------------------------------
CMaxCard
CLogicalAssert::Maxcard
(
IMemoryPool *, // pmp
CExpressionHandle &exprhdl
)
const
{
// in case of a false condition or a contradiction, maxcard should be 1
CExpression *pexprScalar = exprhdl.PexprScalarChild(1);
GPOS_ASSERT(NULL != pexprScalar);
if (CUtils::FScalarConstFalse(pexprScalar) ||
CDrvdPropRelational::Pdprel(exprhdl.Pdp())->Ppc()->FContradiction())
{
return CMaxCard(1 /*ull*/);
}
// if Assert operator was generated from MaxOneRow operator,
// then a max cardinality of 1 is expected
if (NULL != exprhdl.Pgexpr() &&
CXform::ExfMaxOneRow2Assert == exprhdl.Pgexpr()->ExfidOrigin())
{
return CMaxCard(1 /*ull*/);
}
// pass on max card of first child
return exprhdl.Pdprel(0)->Maxcard();
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalAgg::EpetDistribution
//
// @doc:
// Return the enforcing type for distribution property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalAgg::EpetDistribution
(
CExpressionHandle &exprhdl,
const CEnfdDistribution *ped
)
const
{
GPOS_ASSERT(NULL != ped);
// get distribution delivered by the aggregate node
CDistributionSpec *pds = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Pds();
if (ped->FCompatible(pds))
{
if (COperator::EgbaggtypeLocal != Egbaggtype())
{
return CEnfdProp::EpetUnnecessary;
}
// prohibit the plan if local aggregate already delivers the enforced distribution, since
// otherwise we would create two aggregates with no intermediate motion operators
return CEnfdProp::EpetProhibited;
}
// if there are outer refs, we cannot have a motion on top
if (exprhdl.FHasOuterRefs())
{
return CEnfdProp::EpetProhibited;
}
// required distribution will be enforced on Agg's output
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalComputeScalar::EpetOrder
//
// @doc:
// Return the enforcing type for order property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalComputeScalar::EpetOrder
(
CExpressionHandle &exprhdl,
const CEnfdOrder *peo
)
const
{
GPOS_ASSERT(NULL != peo);
GPOS_ASSERT(!peo->PosRequired()->FEmpty());
COrderSpec *pos = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Pos();
if (peo->FCompatible(pos))
{
return CEnfdProp::EpetUnnecessary;
}
// Sort has to go above ComputeScalar if sort columns use any column
// defined by ComputeScalar, otherwise, Sort can either go above or below ComputeScalar
CColRefSet *pcrsSort = peo->PosRequired()->PcrsUsed(m_pmp);
BOOL fUsesDefinedCols = FUnaryUsesDefinedColumns(pcrsSort, exprhdl);
pcrsSort->Release();
if (fUsesDefinedCols)
{
return CEnfdProp::EpetRequired;
}
return CEnfdProp::EpetOptional;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalComputeScalar::EpetRewindability
//
// @doc:
// Return the enforcing type for rewindability property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalComputeScalar::EpetRewindability
(
CExpressionHandle &exprhdl,
const CEnfdRewindability *per
)
const
{
CColRefSet *pcrsUsed = exprhdl.Pdpscalar(1 /*ulChidIndex*/)->PcrsUsed();
CColRefSet *pcrsCorrelatedApply = exprhdl.Pdprel()->PcrsCorrelatedApply();
if (!pcrsUsed->FDisjoint(pcrsCorrelatedApply))
{
// columns are used from inner children of correlated-apply expressions,
// this means that a subplan occurs below the Project operator,
// in this case, rewindability needs to be enforced on operator's output
return CEnfdProp::EpetRequired;
}
CRewindabilitySpec *prs = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Prs();
if (per->FCompatible(prs))
{
// required distribution is already provided
return CEnfdProp::EpetUnnecessary;
}
// rewindability is enforced on operator's output
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalComputeScalar::EpetDistribution
//
// @doc:
// Return the enforcing type for distribution property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalComputeScalar::EpetDistribution
(
CExpressionHandle &exprhdl,
const CEnfdDistribution *ped
)
const
{
GPOS_ASSERT(NULL != ped);
// get distribution delivered by the filter node
CDistributionSpec *pds = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Pds();
if (ped->FCompatible(pds))
{
// required distribution is already provided
return CEnfdProp::EpetUnnecessary;
}
if (exprhdl.FHasOuterRefs())
{
return CEnfdProp::EpetProhibited;
}
return CEnfdProp::EpetRequired;
}
void
CDistributionSpecHashedNoOp::AppendEnforcers
(
IMemoryPool *pmp,
CExpressionHandle &exprhdl,
CReqdPropPlan *,
DrgPexpr *pdrgpexpr,
CExpression *pexpr
)
{
CDrvdProp *pdp = exprhdl.Pdp();
CDistributionSpec *pdsChild = CDrvdPropPlan::Pdpplan(pdp)->Pds();
CDistributionSpecHashed *pdsChildHashed = dynamic_cast<CDistributionSpecHashed *>(pdsChild);
if (NULL == pdsChildHashed)
{
return;
}
DrgPexpr *pdrgpexprNoOpRedistributionColumns = pdsChildHashed->Pdrgpexpr();
pdrgpexprNoOpRedistributionColumns->AddRef();
CDistributionSpecHashedNoOp* pdsNoOp = GPOS_NEW(pmp) CDistributionSpecHashedNoOp(pdrgpexprNoOpRedistributionColumns);
pexpr->AddRef();
CExpression *pexprMotion = GPOS_NEW(pmp) CExpression
(
pmp,
GPOS_NEW(pmp) CPhysicalMotionHashDistribute(pmp, pdsNoOp),
pexpr
);
pdrgpexpr->Append(pexprMotion);
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalPartitionSelectorDML::EpetOrder
//
// @doc:
// Return the enforcing type for order property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalPartitionSelectorDML::EpetOrder
(
CExpressionHandle &exprhdl,
const CEnfdOrder *peo
)
const
{
GPOS_ASSERT(NULL != peo);
GPOS_ASSERT(!peo->PosRequired()->IsEmpty());
COrderSpec *pos = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Pos();
if (peo->FCompatible(pos))
{
return CEnfdProp::EpetUnnecessary;
}
// Sort has to go above if sort columns use any column
// defined here, otherwise, Sort can either go above or below
CColRefSet *pcrsSort = peo->PosRequired()->PcrsUsed(m_mp);
BOOL fUsesDefinedCols = pcrsSort->FMember(m_pcrOid);
pcrsSort->Release();
if (fUsesDefinedCols)
{
return CEnfdProp::EpetRequired;
}
return CEnfdProp::EpetOptional;
}
//---------------------------------------------------------------------------
// @function:
// CPhysical::FProvidesReqdCTEs
//
// @doc:
// Check if required CTEs are included in derived CTE map
//
//---------------------------------------------------------------------------
BOOL
CPhysical::FProvidesReqdCTEs
(
CExpressionHandle &exprhdl,
const CCTEReq *pcter
)
const
{
CCTEMap *pcmDrvd = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->GetCostModel();
GPOS_ASSERT(NULL != pcmDrvd);
return pcmDrvd->FSatisfies(pcter);
}
//---------------------------------------------------------------------------
// @function:
// CLogicalSequenceProject::FHasLocalOuterRefs
//
// @doc:
// Return true if outer references are included in Partition/Order,
// or window frame edges
//
//---------------------------------------------------------------------------
BOOL
CLogicalSequenceProject::FHasLocalOuterRefs
(
CExpressionHandle &exprhdl
)
const
{
GPOS_ASSERT(this == exprhdl.Pop());
CColRefSet *outer_refs = CDrvdPropRelational::GetRelationalProperties(exprhdl.Pdp())->PcrsOuter();
return !(outer_refs->IsDisjoint(m_pcrsLocalUsed));
}
//---------------------------------------------------------------------------
// @function:
// CLogicalDifferenceAll::Maxcard
//
// @doc:
// Derive max card
//
//---------------------------------------------------------------------------
CMaxCard
CLogicalDifferenceAll::Maxcard
(
IMemoryPool *, // pmp
CExpressionHandle &exprhdl
)
const
{
// contradictions produce no rows
if (CDrvdPropRelational::Pdprel(exprhdl.Pdp())->Ppc()->FContradiction())
{
return CMaxCard(0 /*ull*/);
}
return exprhdl.Pdprel(0)->Maxcard();
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalExternalScan::EpetRewindability
//
// @doc:
// Return the enforcing type for rewindability property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalExternalScan::EpetRewindability
(
CExpressionHandle &exprhdl,
const CEnfdRewindability *per
)
const
{
CRewindabilitySpec *prs = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Prs();
if (per->FCompatible(prs))
{
return CEnfdProp::EpetUnnecessary;
}
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalSequenceProject::EpetDistribution
//
// @doc:
// Return the enforcing type for distribution property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalSequenceProject::EpetDistribution
(
CExpressionHandle &exprhdl,
const CEnfdDistribution *ped
)
const
{
GPOS_ASSERT(NULL != ped);
CDistributionSpec *pds = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Pds();
if (ped->FCompatible(pds))
{
// required distribution is already provided
return CEnfdProp::EpetUnnecessary;
}
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalCTEConsumer::EpetRewindability
//
// @doc:
// Return the enforcing type for rewindability property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalCTEConsumer::EpetRewindability
(
CExpressionHandle &exprhdl,
const CEnfdRewindability *per
)
const
{
GPOS_ASSERT(NULL != per);
CRewindabilitySpec *prs = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Prs();
if (per->FCompatible(prs))
{
return CEnfdProp::EpetUnnecessary;
}
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalCTEConsumer::EpetDistribution
//
// @doc:
// Return the enforcing type for distribution property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalCTEConsumer::EpetDistribution
(
CExpressionHandle &exprhdl,
const CEnfdDistribution *ped
)
const
{
GPOS_ASSERT(NULL != ped);
CDistributionSpec *pds = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Pds();
if (ped->FCompatible(pds))
{
return CEnfdProp::EpetUnnecessary;
}
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalRowTrigger::EpetRewindability
//
// @doc:
// Return the enforcing type for rewindability property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalRowTrigger::EpetRewindability
(
CExpressionHandle &exprhdl,
const CEnfdRewindability *per
)
const
{
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 trigger
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalSequenceProject::EpetRewindability
//
// @doc:
// Return the enforcing type for rewindability property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalSequenceProject::EpetRewindability
(
CExpressionHandle &exprhdl,
const CEnfdRewindability *per
)
const
{
CRewindabilitySpec *prs = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Prs();
if (per->FCompatible(prs))
{
// required distribution is already provided
return CEnfdProp::EpetUnnecessary;
}
// rewindability is enforced on operator's output
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalAgg::EpetRewindability
//
// @doc:
// Return the enforcing type for rewindability property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalAgg::EpetRewindability
(
CExpressionHandle &exprhdl,
const CEnfdRewindability *per
)
const
{
// get rewindability delivered by the Agg node
CRewindabilitySpec *prs = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Prs();
if (per->FCompatible(prs))
{
// required rewindability is already provided
return CEnfdProp::EpetUnnecessary;
}
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CLogicalSelect::Maxcard
//
// @doc:
// Derive max card
//
//---------------------------------------------------------------------------
CMaxCard
CLogicalSelect::Maxcard
(
IMemoryPool *, // pmp
CExpressionHandle &exprhdl
)
const
{
// in case of a false condition or a contradiction, maxcard should be zero
CExpression *pexprScalar = exprhdl.PexprScalarChild(1);
if ((NULL != pexprScalar && CUtils::FScalarConstFalse(pexprScalar)) ||
CDrvdPropRelational::Pdprel(exprhdl.Pdp())->Ppc()->FContradiction())
{
return CMaxCard(0 /*ull*/);
}
// pass on max card of first child
return exprhdl.Pdprel(0)->Maxcard();
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalCTEConsumer::EpetOrder
//
// @doc:
// Return the enforcing type for order property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalCTEConsumer::EpetOrder
(
CExpressionHandle &exprhdl,
const CEnfdOrder *peo
)
const
{
GPOS_ASSERT(NULL != peo);
GPOS_ASSERT(!peo->PosRequired()->FEmpty());
COrderSpec *pos = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Pos();
if (peo->FCompatible(pos))
{
return CEnfdProp::EpetUnnecessary;
}
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalJoin::EpetRewindability
//
// @doc:
// Return the enforcing type for rewindability property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalJoin::EpetRewindability
(
CExpressionHandle &exprhdl,
const CEnfdRewindability *per
)
const
{
// get rewindability delivered by the join node
CRewindabilitySpec *prs = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Prs();
if (per->FCompatible(prs))
{
// required rewindability will be established by the join operator
return CEnfdProp::EpetUnnecessary;
}
// required rewindability will be enforced on join's output
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CLogical::Maxcard
//
// @doc:
// Derive max card given scalar child and constraint property. If a
// contradiction is detected then return maxcard of zero, otherwise
// use the given default maxcard
//
//---------------------------------------------------------------------------
CMaxCard
CLogical::Maxcard
(
CExpressionHandle &exprhdl,
ULONG ulScalarIndex,
CMaxCard maxcard
)
{
// in case of a false condition or a contradiction, maxcard should be zero
CExpression *pexprScalar = exprhdl.PexprScalarChild(ulScalarIndex);
if (NULL != pexprScalar &&
(CUtils::FScalarConstFalse(pexprScalar) ||
CDrvdPropRelational::Pdprel(exprhdl.Pdp())->Ppc()->FContradiction()))
{
return CMaxCard(0 /*ull*/);
}
return maxcard;
}
CEnfdProp::EPropEnforcingType
CPhysical::EpetDistribution
(
CExpressionHandle &exprhdl,
const CEnfdDistribution *ped
)
const
{
GPOS_ASSERT(NULL != ped);
// get distribution delivered by the physical node
CDistributionSpec *pds = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Pds();
if (ped->FCompatible(pds))
{
// required distribution is already provided
return CEnfdProp::EpetUnnecessary;
}
// required distribution will be enforced on Assert's output
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalDML::EpetOrder
//
// @doc:
// Return the enforcing type for order property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalDML::EpetOrder
(
CExpressionHandle &exprhdl,
const CEnfdOrder *peo
)
const
{
GPOS_ASSERT(NULL != peo);
GPOS_ASSERT(!peo->PosRequired()->FEmpty());
// get the order delivered by the DML node
COrderSpec *pos = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Pos();
if (peo->FCompatible(pos))
{
return CEnfdProp::EpetUnnecessary;
}
// required order will be enforced on limit's output
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalSequence::EpetOrder
//
// @doc:
// Return the enforcing type for the order property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalSequence::EpetOrder
(
CExpressionHandle &exprhdl,
const CEnfdOrder *peo
)
const
{
GPOS_ASSERT(NULL != peo);
// get order delivered by the sequence node
COrderSpec *pos = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Pos();
if (peo->FCompatible(pos))
{
// required order will be established by the sequence operator
return CEnfdProp::EpetUnnecessary;
}
// required distribution will be enforced on sequence's output
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalJoin::EpetDistribution
//
// @doc:
// Return the enforcing type for distribution property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalJoin::EpetDistribution
(
CExpressionHandle &exprhdl,
const CEnfdDistribution *ped
)
const
{
GPOS_ASSERT(NULL != ped);
// get distribution delivered by the join node
CDistributionSpec *pds = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Pds();
if (ped->FCompatible(pds))
{
// required distribution will be established by the join operator
return CEnfdProp::EpetUnnecessary;
}
// required distribution will be enforced on join's output
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysical::EpetPartitionPropagation
//
// @doc:
// Compute the enforcing type for the operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysical::EpetPartitionPropagation
(
CExpressionHandle &exprhdl,
const CEnfdPartitionPropagation *pepp
)
const
{
CPartIndexMap *ppimReqd = pepp->PppsRequired()->Ppim();
if (!ppimReqd->FContainsUnresolved())
{
// no unresolved partition consumers left
return CEnfdProp::EpetUnnecessary;
}
CPartIndexMap *ppimDrvd = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Ppim();
GPOS_ASSERT(NULL != ppimDrvd);
BOOL fInScope = pepp->FInScope(m_mp, ppimDrvd);
BOOL fResolved = pepp->FResolved(m_mp, ppimDrvd);
if (fResolved)
{
// all required partition consumers are resolved
return CEnfdProp::EpetUnnecessary;
}
if (!fInScope)
{
// some partition consumers are not in scope of the operator: need to enforce these on top
return CEnfdProp::EpetRequired;
}
// all partition resolvers are in scope of the operator: do not enforce them on top
return CEnfdProp::EpetProhibited;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalTVF::EpetRewindability
//
// @doc:
// Return the enforcing type for rewindability property based on this operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalTVF::EpetRewindability
(
CExpressionHandle &exprhdl,
const CEnfdRewindability *per
)
const
{
// get rewindability delivered by the TVF node
CRewindabilitySpec *prs = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Prs();
if (per->FCompatible(prs))
{
// required distribution is already provided
return CEnfdProp::EpetUnnecessary;
}
if (exprhdl.FHasOuterRefs())
{
// a TVF should not have a materialize on top of it if it has an outer ref
return CEnfdProp::EpetProhibited;
}
return CEnfdProp::EpetRequired;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalUnionAll::EpetPartitionPropagation
//
// @doc:
// Compute the enforcing type for the operator
//
//---------------------------------------------------------------------------
CEnfdProp::EPropEnforcingType
CPhysicalUnionAll::EpetPartitionPropagation
(
CExpressionHandle &exprhdl,
const CEnfdPartitionPropagation *pepp
)
const
{
CPartIndexMap *ppimReqd = pepp->PppsRequired()->Ppim();
if (!ppimReqd->FContainsUnresolved())
{
// no unresolved partition consumers left
return CEnfdProp::EpetUnnecessary;
}
CPartIndexMap *ppimDrvd = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Ppim();
GPOS_ASSERT(NULL != ppimDrvd);
BOOL fInScope = pepp->FInScope(m_pmp, ppimDrvd);
BOOL fResolved = pepp->FResolved(m_pmp, ppimDrvd);
if (fResolved)
{
// all required partition consumers are resolved
return CEnfdProp::EpetUnnecessary;
}
if (!fInScope)
{
// some partition consumers are not covered downstream
return CEnfdProp::EpetRequired;
}
DrgPul *pdrgpul = ppimReqd->PdrgpulScanIds(m_pmp);
const ULONG ulScanIds = pdrgpul->UlLength();
const ULONG ulArity = exprhdl.UlNonScalarChildren();
for (ULONG ul = 0; ul < ulScanIds; ul++)
{
ULONG ulScanId = *((*pdrgpul)[ul]);
ULONG ulChildrenWithConsumers = 0;
for (ULONG ulChildIdx = 0; ulChildIdx < ulArity; ulChildIdx++)
{
if (exprhdl.Pdprel(ulChildIdx)->Ppartinfo()->FContainsScanId(ulScanId))
{
ulChildrenWithConsumers++;
}
}
if (1 < ulChildrenWithConsumers)
{
// partition consumer exists in more than one child, so enforce it here
pdrgpul->Release();
return CEnfdProp::EpetRequired;
}
}
pdrgpul->Release();
// required part propagation can be enforced here or passed to the children
return CEnfdProp::EpetOptional;
}
//---------------------------------------------------------------------------
// @function:
// CDistributionSpecRandom::AppendEnforcers
//
// @doc:
// Add required enforcers to dynamic array
//
//---------------------------------------------------------------------------
void
CDistributionSpecRandom::AppendEnforcers
(
IMemoryPool *mp,
CExpressionHandle &exprhdl,
CReqdPropPlan *
#ifdef GPOS_DEBUG
prpp
#endif // GPOS_DEBUG
,
CExpressionArray *pdrgpexpr,
CExpression *pexpr
)
{
GPOS_ASSERT(NULL != mp);
GPOS_ASSERT(NULL != prpp);
GPOS_ASSERT(NULL != pdrgpexpr);
GPOS_ASSERT(NULL != pexpr);
GPOS_ASSERT(!GPOS_FTRACE(EopttraceDisableMotions));
GPOS_ASSERT(this == prpp->Ped()->PdsRequired() &&
"required plan properties don't match enforced distribution spec");
if (GPOS_FTRACE(EopttraceDisableMotionRandom))
{
// random Motion is disabled
return;
}
// random motion added on top of a child delivering universal
// spec is converted to a result node with hash filters in dxl to planned
// statement translator. So, mark the spec of such a motion as random spec
// as it will not be ultimately enforced by a motion.
//
// consider the query: INSERT INTO t1_random VALUES (1), (2);
// where t1_random is randomly distributed.
// the below plan shows the physical plan with random motion enforced in
// physical stage, and the GPDB plan which translated the motion node on
// top of universal spec child to a result node
// Physical plan:
// +--CPhysicalDML (Insert, "t1_random"), Source Columns: ["a" (0)], Action: ("ColRef_0001" (1))
// +--CPhysicalMotionRandom (#1)
// +--CPhysicalComputeScalar
// |--CPhysicalMotionRandom (#2) ==> Motion delivers duplicate hazard
// | +--CPhysicalConstTableGet Columns: ["a" (0)] Values: [(1); (2)] ==> Derives universal spec
// +--CScalarProjectList origin: [Grp:9, GrpExpr:0]
// +--CScalarProjectElement "ColRef_0001" (1)
// +--CScalarConst (1)
//
// Insert (cost=0.00..0.03 rows=1 width=4)
// -> Redistribute Motion 1:1 (slice1; segments: 1) (cost=0.00..0.00 rows=1 width=8) ==> Random Distribution
// -> Result (cost=0.00..0.00 rows=1 width=8)
// -> Result (cost=0.00..0.00 rows=1 width=1) (#2) ==> Motion converted to Result Node
// -> Values Scan on "Values" (cost=0.00..0.00 rows=2 width=4) ==> Derives universal spec
CDistributionSpec *expr_dist_spec = CDrvdPropPlan::Pdpplan(exprhdl.Pdp())->Pds();
CDistributionSpecRandom *random_dist_spec = NULL;
if (expr_dist_spec->Edt() == CDistributionSpec::EdtUniversal)
{
// the motion node is enforced on top of a child
// deriving universal spec, this motion node will be
// translated to a result node with hash filter to remove
// duplicates
random_dist_spec = GPOS_NEW(mp) CDistributionSpecRandom();
}
else
{
// the motion added in this enforcer will translate to
// a redistribute motion
random_dist_spec = GPOS_NEW(mp) CDistributionSpecStrictRandom();
}
// add a distribution enforcer
pexpr->AddRef();
CExpression *pexprMotion = GPOS_NEW(mp) CExpression
(
mp,
GPOS_NEW(mp) CPhysicalMotionRandom(mp, random_dist_spec),
pexpr
);
pdrgpexpr->Append(pexprMotion);
}
