//--------------------------------------------------------------------------- // @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); }