//--------------------------------------------------------------------------- // @function: // CDXLPhysicalRandomMotion::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLPhysicalRandomMotion::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { // assert proj list and filter are valid CDXLPhysical::AssertValid(pdxln, fValidateChildren); GPOS_ASSERT(m_pdrgpiInputSegIds != NULL); GPOS_ASSERT(0 < m_pdrgpiInputSegIds->UlLength()); GPOS_ASSERT(m_pdrgpiOutputSegIds != NULL); GPOS_ASSERT(0 < m_pdrgpiOutputSegIds->UlLength()); GPOS_ASSERT(EdxlrandommIndexSentinel == pdxln->UlArity()); CDXLNode *pdxlnChild = (*pdxln)[EdxlrandommIndexChild]; GPOS_ASSERT(EdxloptypePhysical == pdxlnChild->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } }
//--------------------------------------------------------------------------- // @function: // CDXLScalarWindowFrameEdge::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLScalarWindowFrameEdge::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { const ULONG ulArity = pdxln->UlArity(); GPOS_ASSERT(1 >= ulArity); GPOS_ASSERT_IMP((m_edxlfb == EdxlfbBoundedPreceding || m_edxlfb == EdxlfbBoundedFollowing || m_edxlfb == EdxlfbDelayedBoundedPreceding || m_edxlfb == EdxlfbDelayedBoundedFollowing), 1 == ulArity); GPOS_ASSERT_IMP((m_edxlfb == EdxlfbUnboundedPreceding || m_edxlfb == EdxlfbUnboundedFollowing || m_edxlfb == EdxlfbCurrentRow), 0 == ulArity); for (ULONG ul = 0; ul < ulArity; ++ul) { CDXLNode *pdxlnArg = (*pdxln)[ul]; GPOS_ASSERT(EdxloptypeScalar == pdxlnArg->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnArg->Pdxlop()->AssertValid(pdxlnArg, fValidateChildren); } } }
//--------------------------------------------------------------------------- // @function: // CDXLScalarBitmapBoolOp::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLScalarBitmapBoolOp::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { EdxlBitmapBoolOp edxlbitmapboolop = ((CDXLScalarBitmapBoolOp *) pdxln->Pdxlop())->Edxlbitmapboolop(); GPOS_ASSERT( (edxlbitmapboolop == EdxlbitmapAnd) || (edxlbitmapboolop == EdxlbitmapOr)); ULONG ulArity = pdxln->UlArity(); GPOS_ASSERT(2 == ulArity); for (ULONG ul = 0; ul < ulArity; ++ul) { CDXLNode *pdxlnArg = (*pdxln)[ul]; Edxlopid edxlop = pdxlnArg->Pdxlop()->Edxlop(); GPOS_ASSERT(EdxlopScalarBitmapBoolOp == edxlop || EdxlopScalarBitmapIndexProbe == edxlop); if (fValidateChildren) { pdxlnArg->Pdxlop()->AssertValid(pdxlnArg, fValidateChildren); } } }
//--------------------------------------------------------------------------- // @function: // CDXLScalarBoolExpr::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLScalarBoolExpr::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { EdxlBoolExprType edxlbooltype = ((CDXLScalarBoolExpr *) pdxln->Pdxlop())->EdxlBoolType(); GPOS_ASSERT( (edxlbooltype == Edxlnot) || (edxlbooltype == Edxlor) || (edxlbooltype == Edxland)); const ULONG ulArity = pdxln->UlArity(); if(edxlbooltype == Edxlnot) { GPOS_ASSERT(1 == ulArity); } else { GPOS_ASSERT(2 <= ulArity); } for (ULONG ul = 0; ul < ulArity; ++ul) { CDXLNode *pdxlnArg = (*pdxln)[ul]; GPOS_ASSERT(EdxloptypeScalar == pdxlnArg->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnArg->Pdxlop()->AssertValid(pdxlnArg, fValidateChildren); } } }
//--------------------------------------------------------------------------- // @function: // CDXLLogicalWindow::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLLogicalWindow::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { GPOS_ASSERT(2 == pdxln->UlArity()); CDXLNode *pdxlnProjList = (*pdxln)[0]; CDXLNode *pdxlnChild = (*pdxln)[1]; GPOS_ASSERT(EdxlopScalarProjectList == pdxlnProjList->Pdxlop()->Edxlop()); GPOS_ASSERT(EdxloptypeLogical == pdxlnChild->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnProjList->Pdxlop()->AssertValid(pdxlnProjList, fValidateChildren); pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } const ULONG ulArity = pdxlnProjList->UlArity(); for (ULONG ul = 0; ul < ulArity; ++ul) { CDXLNode *pdxlnPrEl = (*pdxlnProjList)[ul]; GPOS_ASSERT(EdxlopScalarIdent != pdxlnPrEl->Pdxlop()->Edxlop()); } GPOS_ASSERT(NULL != m_pdrgpdxlws); GPOS_ASSERT(0 < m_pdrgpdxlws->UlLength()); }
//--------------------------------------------------------------------------- // @function: // CDXLPhysicalResult::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLPhysicalResult::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { GPOS_ASSERT(EdxlresultIndexSentinel >= pdxln->UlArity()); // check that one time filter is valid CDXLNode *pdxlnOneTimeFilter = (*pdxln)[EdxlresultIndexOneTimeFilter]; GPOS_ASSERT(EdxlopScalarOneTimeFilter == pdxlnOneTimeFilter->Pdxlop()->Edxlop()); if (fValidateChildren) { pdxlnOneTimeFilter->Pdxlop()->AssertValid(pdxlnOneTimeFilter, fValidateChildren); } if (EdxlresultIndexSentinel == pdxln->UlArity()) { CDXLNode *pdxlnChild = (*pdxln)[EdxlresultIndexChild]; GPOS_ASSERT(EdxloptypePhysical == pdxlnChild->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } } }
//--------------------------------------------------------------------------- // @function: // CDXLPhysicalIndexScan::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLPhysicalIndexScan::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { // assert proj list and filter are valid CDXLPhysical::AssertValid(pdxln, fValidateChildren); // index scan has only 3 children GPOS_ASSERT(3 == pdxln->UlArity()); // assert validity of the index descriptor GPOS_ASSERT(NULL != m_pdxlid); GPOS_ASSERT(NULL != m_pdxlid->Pmdname()); GPOS_ASSERT(m_pdxlid->Pmdname()->Pstr()->FValid()); // assert validity of the table descriptor GPOS_ASSERT(NULL != m_pdxltabdesc); GPOS_ASSERT(NULL != m_pdxltabdesc->Pmdname()); GPOS_ASSERT(m_pdxltabdesc->Pmdname()->Pstr()->FValid()); CDXLNode *pdxlnIndexConds = (*pdxln)[EdxlisIndexCondition]; // assert children are of right type (physical/scalar) GPOS_ASSERT(EdxlopScalarIndexCondList == pdxlnIndexConds->Pdxlop()->Edxlop()); if (fValidateChildren) { pdxlnIndexConds->Pdxlop()->AssertValid(pdxlnIndexConds, fValidateChildren); } }
//--------------------------------------------------------------------------- // @function: // CDXLPhysicalLimit::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLPhysicalLimit::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { GPOS_ASSERT(4 == pdxln->UlArity()); // Assert proj list is valid CDXLNode *pdxlnProjList = (*pdxln)[EdxllimitIndexProjList]; GPOS_ASSERT(EdxlopScalarProjectList == pdxlnProjList->Pdxlop()->Edxlop()); // assert child plan is a physical plan and is valid CDXLNode *pdxlnChild = (*pdxln)[EdxllimitIndexChildPlan]; GPOS_ASSERT(EdxloptypePhysical == pdxlnChild->Pdxlop()->Edxloperatortype()); // Assert the validity of Count and Offset CDXLNode *pdxlnCount = (*pdxln)[EdxllimitIndexLimitCount]; GPOS_ASSERT(EdxlopScalarLimitCount == pdxlnCount->Pdxlop()->Edxlop()); CDXLNode *pdxlnOffset = (*pdxln)[EdxllimitIndexLimitOffset]; GPOS_ASSERT(EdxlopScalarLimitOffset == pdxlnOffset->Pdxlop()->Edxlop()); if (fValidateChildren) { pdxlnProjList->Pdxlop()->AssertValid(pdxlnProjList, fValidateChildren); pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); pdxlnCount->Pdxlop()->AssertValid(pdxlnCount, fValidateChildren); pdxlnOffset->Pdxlop()->AssertValid(pdxlnOffset, fValidateChildren); } }
//--------------------------------------------------------------------------- // @function: // CDXLPhysicalMergeJoin::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLPhysicalMergeJoin::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { // assert proj list and filter are valid CDXLPhysical::AssertValid(pdxln, fValidateChildren); GPOS_ASSERT(EdxlmjIndexSentinel == pdxln->UlArity()); GPOS_ASSERT(EdxljtSentinel > Edxltype()); CDXLNode *pdxlnJoinFilter = (*pdxln)[EdxlmjIndexJoinFilter]; CDXLNode *pdxlnMergeClauses = (*pdxln)[EdxlmjIndexMergeCondList]; CDXLNode *pdxlnLeft = (*pdxln)[EdxlmjIndexLeftChild]; CDXLNode *pdxlnRight = (*pdxln)[EdxlmjIndexRightChild]; // assert children are of right type (physical/scalar) GPOS_ASSERT(EdxlopScalarJoinFilter == pdxlnJoinFilter->Pdxlop()->Edxlop()); GPOS_ASSERT(EdxlopScalarMergeCondList == pdxlnMergeClauses->Pdxlop()->Edxlop()); GPOS_ASSERT(EdxloptypePhysical == pdxlnLeft->Pdxlop()->Edxloperatortype()); GPOS_ASSERT(EdxloptypePhysical == pdxlnRight->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnJoinFilter->Pdxlop()->AssertValid(pdxlnJoinFilter, fValidateChildren); pdxlnMergeClauses->Pdxlop()->AssertValid(pdxlnMergeClauses, fValidateChildren); pdxlnLeft->Pdxlop()->AssertValid(pdxlnLeft, fValidateChildren); pdxlnRight->Pdxlop()->AssertValid(pdxlnRight, fValidateChildren); } }
//--------------------------------------------------------------------------- // @function: // CDXLPhysicalDML::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLPhysicalDML::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { GPOS_ASSERT(2 == pdxln->UlArity()); CDXLNode *pdxlnChild = (*pdxln)[1]; GPOS_ASSERT(EdxloptypePhysical == pdxlnChild->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } }
//--------------------------------------------------------------------------- // @function: // CDXLScalarCoerceViaIO::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLScalarCoerceViaIO::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { GPOS_ASSERT(1 == pdxln->UlArity()); CDXLNode *pdxlnChild = (*pdxln)[0]; GPOS_ASSERT(EdxloptypeScalar == pdxlnChild->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } }
//--------------------------------------------------------------------------- // @function: // CDXLLogicalDelete::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLLogicalDelete::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { GPOS_ASSERT(1 == pdxln->UlArity()); CDXLNode *pdxlnChild = (*pdxln)[0]; GPOS_ASSERT(EdxloptypeLogical == pdxlnChild->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } }
//--------------------------------------------------------------------------- // @function: // CDXLPhysicalCTEConsumer::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLPhysicalCTEConsumer::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { GPOS_ASSERT(1 == pdxln->UlArity()); CDXLNode *pdxlnPrL = (*pdxln)[0]; GPOS_ASSERT(EdxlopScalarProjectList == pdxlnPrL->Pdxlop()->Edxlop()); if (fValidateChildren) { pdxlnPrL->Pdxlop()->AssertValid(pdxlnPrL, fValidateChildren); } }
//--------------------------------------------------------------------------- // @function: // CDXLPhysicalMaterialize::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLPhysicalMaterialize::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { GPOS_ASSERT(EdxlspoolNone == m_edxlsptype || EdxlspoolMaterialize == m_edxlsptype); GPOS_ASSERT(EdxlmatIndexSentinel == pdxln->UlArity()); CDXLNode *pdxlnChild = (*pdxln)[EdxlmatIndexChild]; GPOS_ASSERT(EdxloptypePhysical == pdxlnChild->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } }
//--------------------------------------------------------------------------- // @function: // CDXLScalarSortColList::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLScalarSortColList::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { const ULONG ulArity = pdxln->UlArity(); for (ULONG ul = 0; ul < ulArity; ul++) { CDXLNode *pdxlnChild = (*pdxln)[ul]; GPOS_ASSERT(EdxlopScalarSortCol == pdxlnChild->Pdxlop()->Edxlop()); if (fValidateChildren) { pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } } }
//--------------------------------------------------------------------------- // @function: // CDXLScalarIndexCondList::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLScalarIndexCondList::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { GPOS_ASSERT(NULL != pdxln); if (fValidateChildren) { const ULONG ulArity = pdxln->UlArity(); for (ULONG ul = 0; ul < ulArity; ul++) { CDXLNode *pdxlnChild = (*pdxln)[ul]; GPOS_ASSERT(EdxloptypeScalar == pdxlnChild->Pdxlop()->Edxloperatortype()); pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } } }
//--------------------------------------------------------------------------- // @function: // CDXLPhysicalSort::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLPhysicalSort::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { // assert proj list and filter are valid CDXLPhysical::AssertValid(pdxln, fValidateChildren); GPOS_ASSERT(EdxlsortIndexSentinel == pdxln->UlArity()); CDXLNode *pdxlnSortColList = (*pdxln)[EdxlsortIndexSortColList]; CDXLNode *pdxlnChild = (*pdxln)[EdxlsortIndexChild]; CDXLNode *pdxlnLimitCount = (*pdxln)[EdxlsortIndexLimitCount]; CDXLNode *pdxlnLimitOffset = (*pdxln)[EdxlsortIndexLimitOffset]; // assert children are of right type (physical/scalar) GPOS_ASSERT(EdxloptypeScalar == pdxlnSortColList->Pdxlop()->Edxloperatortype()); GPOS_ASSERT(EdxloptypePhysical == pdxlnChild->Pdxlop()->Edxloperatortype()); GPOS_ASSERT(EdxlopScalarLimitCount == pdxlnLimitCount->Pdxlop()->Edxlop()); GPOS_ASSERT(EdxlopScalarLimitOffset == pdxlnLimitOffset->Pdxlop()->Edxlop()); // there must be at least one sorting column GPOS_ASSERT(pdxlnSortColList->UlArity() > 0); if (fValidateChildren) { pdxlnSortColList->Pdxlop()->AssertValid(pdxlnSortColList, fValidateChildren); pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } }
//--------------------------------------------------------------------------- // @function: // CDXLScalarSubPlan::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLScalarSubPlan::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { GPOS_ASSERT(EdxlSubPlanIndexSentinel == pdxln->UlArity()); // assert child plan is a physical plan and is valid CDXLNode *pdxlnChild = (*pdxln)[EdxlSubPlanIndexChildPlan]; GPOS_ASSERT(NULL != pdxlnChild); GPOS_ASSERT(EdxloptypePhysical == pdxlnChild->Pdxlop()->Edxloperatortype()); GPOS_ASSERT_IMP(NULL != m_pdxlnTestExpr, EdxloptypeScalar == m_pdxlnTestExpr->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } }
//--------------------------------------------------------------------------- // @function: // CDXLScalarIfStmt::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLScalarIfStmt::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { const ULONG ulArity = pdxln->UlArity(); GPOS_ASSERT(3 == ulArity); for (ULONG ul = 0; ul < ulArity; ++ul) { CDXLNode *pdxlnArg = (*pdxln)[ul]; GPOS_ASSERT(EdxloptypeScalar == pdxlnArg->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnArg->Pdxlop()->AssertValid(pdxlnArg, fValidateChildren); } } }
//--------------------------------------------------------------------------- // @function: // CDXLPhysicalAppend::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLPhysicalAppend::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { // assert proj list and filter are valid CDXLPhysical::AssertValid(pdxln, fValidateChildren); const ULONG ulChildren = pdxln->UlArity(); for (ULONG ul = EdxlappendIndexFirstChild; ul < ulChildren; ul++) { CDXLNode *pdxlnChild = (*pdxln)[ul]; GPOS_ASSERT(EdxloptypePhysical == pdxlnChild->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } } }
//--------------------------------------------------------------------------- // @function: // CDXLPhysicalSequence::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLPhysicalSequence::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { const ULONG ulArity = pdxln->UlArity(); GPOS_ASSERT(1 < ulArity); for (ULONG ul = 1; ul < ulArity; ul++) { CDXLNode *pdxlnChild = (*pdxln)[ul]; GPOS_ASSERT(EdxloptypePhysical == pdxlnChild->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } } }
//--------------------------------------------------------------------------- // @function: // CDXLScalarAggref::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLScalarAggref::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { EdxlAggrefStage edxlaggrefstage = ((CDXLScalarAggref*) pdxln->Pdxlop())->Edxlaggstage(); GPOS_ASSERT((EdxlaggstageFinal >= edxlaggrefstage) && (EdxlaggstageNormal <= edxlaggrefstage)); const ULONG ulArity = pdxln->UlArity(); for (ULONG ul = 0; ul < ulArity; ++ul) { CDXLNode *pdxlnAggrefArg = (*pdxln)[ul]; GPOS_ASSERT(EdxloptypeScalar == pdxlnAggrefArg->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnAggrefArg->Pdxlop()->AssertValid(pdxlnAggrefArg, fValidateChildren); } } }
//--------------------------------------------------------------------------- // @function: // CDXLScalarWindowRef::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLScalarWindowRef::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { EdxlWinStage edxlwinrefstage = ((CDXLScalarWindowRef*) pdxln->Pdxlop())->Edxlwinstage(); GPOS_ASSERT((EdxlwinstageSentinel >= edxlwinrefstage)); const ULONG ulArity = pdxln->UlArity(); for (ULONG ul = 0; ul < ulArity; ++ul) { CDXLNode *pdxlnWinrefArg = (*pdxln)[ul]; GPOS_ASSERT(EdxloptypeScalar == pdxlnWinrefArg->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnWinrefArg->Pdxlop()->AssertValid(pdxlnWinrefArg, fValidateChildren); } } }
//--------------------------------------------------------------------------- // @function: // CDXLPhysicalTVF::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLPhysicalTVF::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { // assert validity of function id and return type GPOS_ASSERT(NULL != m_pmdidFunc); GPOS_ASSERT(NULL != m_pmdidRetType); const ULONG ulArity = pdxln->UlArity(); for (ULONG ul = 0; ul < ulArity; ++ul) { CDXLNode *pdxlnArg = (*pdxln)[ul]; GPOS_ASSERT(EdxloptypeScalar == pdxlnArg->Pdxlop()->Edxloperatortype()); if (fValidateChildren) { pdxlnArg->Pdxlop()->AssertValid(pdxlnArg, fValidateChildren); } } }
//--------------------------------------------------------------------------- // @function: // CDXLNode::AssertValid // // @doc: // Checks whether node is well-structured // //--------------------------------------------------------------------------- void CDXLNode::AssertValid ( BOOL fValidateChildren ) const { if (!fValidateChildren) { return; } const ULONG ulArity = UlArity(); for (ULONG ul = 0; ul < ulArity; ul++) { CDXLNode *pdxlnChild = (*this)[ul]; pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } }
//--------------------------------------------------------------------------- // @function: // CDXLPhysicalWindow::AssertValid // // @doc: // Checks whether operator node is well-structured // //--------------------------------------------------------------------------- void CDXLPhysicalWindow::AssertValid ( const CDXLNode *pdxln, BOOL fValidateChildren ) const { // assert proj list and filter are valid CDXLPhysical::AssertValid(pdxln, fValidateChildren); GPOS_ASSERT(NULL != m_pdrgpulPartCols); GPOS_ASSERT(NULL != m_pdrgpdxlwk); GPOS_ASSERT(EdxlwindowIndexSentinel == pdxln->UlArity()); CDXLNode *pdxlnChild = (*pdxln)[EdxlwindowIndexChild]; if (fValidateChildren) { pdxlnChild->Pdxlop()->AssertValid(pdxlnChild, fValidateChildren); } }
//--------------------------------------------------------------------------- // @function: // CTranslatorDXLToQuery::TranslateProjList // // @doc: // Translates a DXL projection list // //--------------------------------------------------------------------------- void CTranslatorDXLToQuery::TranslateProjList ( const CDXLNode *pdxlnPrL, CStateDXLToQuery *pstatedxltoquery, CMappingColIdVarQuery *pmapcidvarquery, ULONG ulTargetEntryIndex ) { if (NULL != pdxlnPrL) { // translate each DXL project element into a target entry const ULONG ulArity = pdxlnPrL->UlArity(); for (ULONG ul = 0; ul < ulArity; ++ul) { CDXLNode *pdxlnPrEl = (*pdxlnPrL)[ul]; CDXLScalarProjElem *pdxlopPrEl = CDXLScalarProjElem::PdxlopConvert(pdxlnPrEl->Pdxlop()); GPOS_ASSERT(1 == pdxlnPrEl->UlArity()); // translate proj element expression CDXLNode *pdxlnExpr = (*pdxlnPrEl)[0]; Expr *pexpr = m_pdxlsctranslator->PexprFromDXLNodeScalar(pdxlnExpr, pmapcidvarquery); GPOS_ASSERT(NULL != pexpr); TargetEntry *pte = MakeNode(TargetEntry); pte->expr = pexpr; pte->resname = CTranslatorUtils::SzFromWsz(pdxlopPrEl->PmdnameAlias()->Pstr()->Wsz()); pte->resno = (AttrNumber) (ulTargetEntryIndex + ul + 1); pstatedxltoquery->AddOutputColumnEntry(pte, pte->resname, pdxlopPrEl->UlId()); //save mapping col id -> Var in the query translation context pmapcidvarquery->FInsertMapping(pdxlopPrEl->UlId(), pte); } } }
//--------------------------------------------------------------------------- // @function: // CConstExprEvaluatorDXL::PexprEval // // @doc: // Evaluate the given expression and return the result as a new expression. // Caller takes ownership of returned expression // //--------------------------------------------------------------------------- CExpression * CConstExprEvaluatorDXL::PexprEval ( CExpression *pexpr ) { GPOS_ASSERT(NULL != pexpr); const CHAR *szErrorMsg = ""; if (!FValidInput(pexpr, &szErrorMsg)) { GPOS_RAISE(gpopt::ExmaGPOPT, gpopt::ExmiEvalUnsupportedScalarExpr, szErrorMsg); } CDXLNode *pdxlnExpr = m_trexpr2dxl.PdxlnScalar(pexpr); CDXLNode *pdxlnResult = m_pconstdxleval->PdxlnEvaluateExpr(pdxlnExpr); GPOS_ASSERT(EdxloptypeScalar == pdxlnResult->Pdxlop()->Edxloperatortype()); CExpression *pexprResult = m_trdxl2expr.PexprTranslateScalar(pdxlnResult, NULL /*pdrgpcr*/); pdxlnResult->Release(); pdxlnExpr->Release(); return pexprResult; }
//--------------------------------------------------------------------------- // @function: // CTranslatorDXLToQuery::SetQueryOutput // // @doc: // Set query target list based on the DXL query output // //--------------------------------------------------------------------------- void CTranslatorDXLToQuery::SetQueryOutput ( const DrgPdxln *pdrgpdxlnQueryOutput, Query *pquery, CStateDXLToQuery *pstatedxltoquery, CMappingColIdVarQuery *pmapcidvarquery ) { GPOS_ASSERT(NULL != pdrgpdxlnQueryOutput && NULL != pquery); CStateDXLToQuery *pstatedxltoqueryOutput = New(m_pmp) CStateDXLToQuery(m_pmp); List *plTE = NIL; ULONG ulResno = 0; const ULONG ulLen = pdrgpdxlnQueryOutput->UlLength(); // translate each DXL scalar ident into a target entry for (ULONG ul = 0; ul < ulLen; ul++) { CDXLNode *pdxlnIdent = (*pdrgpdxlnQueryOutput)[ul]; CDXLScalarIdent *pdxlop = CDXLScalarIdent::PdxlopConvert(pdxlnIdent->Pdxlop()); const CDXLColRef *pdxlcr = pdxlop->Pdxlcr(); GPOS_ASSERT(NULL != pdxlcr); const ULONG ulColId = pdxlcr->UlID(); const CMDName *pmdname = pdxlcr->Pmdname(); const TargetEntry *pte = pmapcidvarquery->Pte(ulColId); ulResno++; TargetEntry *pteCopy = (TargetEntry*) gpdb::PvCopyObject(const_cast<TargetEntry*>(pte)); pteCopy->resname = CTranslatorUtils::SzFromWsz(pmdname->Pstr()->Wsz()); pteCopy->resno = (AttrNumber) ulResno; pstatedxltoqueryOutput->AddOutputColumnEntry(pteCopy, pteCopy->resname, ulColId); plTE = gpdb::PlAppendElement(plTE, pteCopy); } const ULONG ulSize = pstatedxltoquery->UlLength(); // Add grouping and ordering columns that are not in the query output in the // target list as resjunk entries. ULONG ulCounter = 0; for (ULONG ul = 0; ul < ulSize ; ul++) { TargetEntry *pte = pstatedxltoquery->PteColumn(ul); GPOS_ASSERT(NULL != pte); // we are only interested in grouping and ordering columns if(pte->ressortgroupref > 0) { // check if we have already added the corresponding pte entry in pplTE BOOL fres = pstatedxltoqueryOutput->FTEFound(pte); if(!fres) { ULONG ulColId = pstatedxltoquery->UlColId(ul); ulResno++; // copy the entries TargetEntry *pteCopy = (TargetEntry*) gpdb::PvCopyObject(pte); pteCopy->resno = (AttrNumber) ulResno; pteCopy->resjunk = true; pstatedxltoqueryOutput->AddOutputColumnEntry(pteCopy, pteCopy->resname, ulColId); plTE = gpdb::PlAppendElement(plTE, pteCopy); } } ulCounter++; } pstatedxltoquery->Reload(pstatedxltoqueryOutput); delete pstatedxltoqueryOutput; pquery->targetList = plTE; }
//--------------------------------------------------------------------------- // @function: // CTranslatorDXLToQuery::TranslateLimit // // @doc: // Translate a logical limit operator // //--------------------------------------------------------------------------- void CTranslatorDXLToQuery::TranslateLimit ( const CDXLNode *pdxln, Query *pquery, CStateDXLToQuery *pstatedxltoquery, CMappingColIdVarQuery *pmapcidvarquery ) { List *plSortCl = NIL; GPOS_ASSERT(4 == pdxln->UlArity()); // get children CDXLNode *pdxlnSortColList = (*pdxln)[0]; CDXLNode *pdxlnLimitCount = (*pdxln)[1]; CDXLNode *pdxlnLimitOffset = (*pdxln)[2]; CDXLNode *pdxlnChild = (*pdxln)[3]; // translate child node TranslateLogicalOp(pdxlnChild, pquery, pstatedxltoquery, pmapcidvarquery); // translate sorting column lists const ULONG ulNumSortCols = pdxlnSortColList->UlArity(); if (0 < ulNumSortCols) { for (ULONG ul = 0; ul < ulNumSortCols; ul++) { CDXLNode *pdxlnSortCol = (*pdxlnSortColList)[ul]; CDXLScalarSortCol *pdxlopSortCol = CDXLScalarSortCol::PdxlopConvert(pdxlnSortCol->Pdxlop()); // get the target entry and the set the sortgroupref ULONG ulSortColId = pdxlopSortCol->UlColId(); TargetEntry *pte = const_cast<TargetEntry *>(pmapcidvarquery->Pte(ulSortColId)); GPOS_ASSERT(NULL != pte); // create the sort clause SortClause *psortcl = MakeNode(SortClause); psortcl->sortop = CMDIdGPDB::PmdidConvert(pdxlopSortCol->PmdidSortOp())->OidObjectId(); plSortCl = gpdb::PlAppendElement(plSortCl, psortcl); // If ressortgroupref is not set then this column // was not used as a grouping column. if(0 == pte->ressortgroupref) { m_ulSortgrouprefCounter++; pte->ressortgroupref = m_ulSortgrouprefCounter; } psortcl->tleSortGroupRef = pte->ressortgroupref; if(!pstatedxltoquery->FTEFound(pte)) { pstatedxltoquery->AddOutputColumnEntry(pte, pte->resname, ulSortColId); } } } GPOS_ASSERT(NULL != pdxlnLimitCount && NULL != pdxlnLimitOffset); // translate the limit count and offset; if(pdxlnLimitCount->UlArity() >0) { Expr *pexprCount = m_pdxlsctranslator->PexprFromDXLNodeScalar ( (*pdxlnLimitCount)[0], pmapcidvarquery ); pquery->limitCount = (Node *) pexprCount; } if(pdxlnLimitOffset->UlArity() >0) { Expr *pexprOffset = m_pdxlsctranslator->PexprFromDXLNodeScalar ( (*pdxlnLimitOffset)[0], pmapcidvarquery ); pquery->limitOffset = (Node *) pexprOffset; } pquery->sortClause = plSortCl; }