//--------------------------------------------------------------------------- // @function: // CParseHandlerQuery::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerQuery::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes& // attrs ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenQuery), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } GPOS_ASSERT(NULL != m_pmp); // create parse handler for the query output node CParseHandlerBase *pphQueryOutput = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenQueryOutput), m_pphm, this); // create parse handler for the CTE list CParseHandlerBase *pphCTE = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenCTEList), m_pphm, this); // create a parse handler for logical nodes CParseHandlerBase *pph = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenLogical), m_pphm, this); m_pphm->ActivateParseHandler(pph); m_pphm->ActivateParseHandler(pphCTE); m_pphm->ActivateParseHandler(pphQueryOutput); // store parse handlers this->Append(pphQueryOutput); this->Append(pphCTE); this->Append(pph); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerAssert::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerAssert::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenPhysicalAssert), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // construct node from the created child nodes CParseHandlerProperties *pphProp = dynamic_cast<CParseHandlerProperties *>((*this)[0]); CParseHandlerProjList *pphPrL = dynamic_cast<CParseHandlerProjList*>((*this)[1]); CParseHandlerScalarAssertConstraintList *pphAssertPredicate = dynamic_cast<CParseHandlerScalarAssertConstraintList *>((*this)[2]); CParseHandlerPhysicalOp *pphChild = dynamic_cast<CParseHandlerPhysicalOp*>((*this)[3]); m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, m_pdxlop); CParseHandlerUtils::SetProperties(m_pdxln, pphProp); // add constructed children AddChildFromParseHandler(pphPrL); AddChildFromParseHandler(pphAssertPredicate); AddChildFromParseHandler(pphChild); #ifdef GPOS_DEBUG m_pdxlop->AssertValid(m_pdxln, false /* fValidateChildren */); #endif // GPOS_DEBUG // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerDistinctComp::EndElement // // @doc: // Processes a Xerces end element event // //--------------------------------------------------------------------------- void CParseHandlerDistinctComp::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarDistinctComp), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // construct node from the created child nodes m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, m_pdxlop); CParseHandlerScalarOp *pphLeft = dynamic_cast<CParseHandlerScalarOp *>((*this)[0]); CParseHandlerScalarOp *pphRight = dynamic_cast<CParseHandlerScalarOp *>((*this)[1]); // add constructed children AddChildFromParseHandler(pphLeft); AddChildFromParseHandler(pphRight); // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerLogicalSelect::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerLogicalSelect::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes& //attrs ) { if(0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenLogicalSelect), xmlszLocalname)) { m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLLogicalSelect(m_pmp)); // create child node parsers // parse handler for logical operator CParseHandlerBase *pphChild = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenLogical), m_pphm, this); m_pphm->ActivateParseHandler(pphChild); // parse handler for the scalar condition CParseHandlerBase *pphOp = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalar), m_pphm, this); m_pphm->ActivateParseHandler(pphOp); // store child parse handler in array this->Append(pphOp); this->Append(pphChild); } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerLogicalInsert::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerLogicalInsert::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes &attrs ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenLogicalInsert), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } const XMLCh *xmlszSourceColIds = CDXLOperatorFactory::XmlstrFromAttrs(attrs, EdxltokenInsertCols, EdxltokenLogicalInsert); m_pdrgpul = CDXLOperatorFactory::PdrgpulFromXMLCh(m_pphm->Pmm(), xmlszSourceColIds, EdxltokenInsertCols, EdxltokenLogicalInsert); // create child node parsers // parse handler for logical operator CParseHandlerBase *pphChild = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenLogical), m_pphm, this); m_pphm->ActivateParseHandler(pphChild); //parse handler for the table descriptor CParseHandlerBase *pphTabDesc = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenTableDescr), m_pphm, this); m_pphm->ActivateParseHandler(pphTabDesc); // store child parse handler in array this->Append(pphTabDesc); this->Append(pphChild); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerLogicalSelect::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerLogicalSelect::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenLogicalSelect), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } GPOS_ASSERT(NULL != m_pdxln ); CParseHandlerScalarOp *pphOp = dynamic_cast<CParseHandlerScalarOp*>((*this)[0]); CParseHandlerLogicalOp *pphChild = dynamic_cast<CParseHandlerLogicalOp*>((*this)[1]); AddChildFromParseHandler(pphOp); AddChildFromParseHandler(pphChild); #ifdef GPOS_DEBUG m_pdxln->Pdxlop()->AssertValid(m_pdxln, false /* fValidateChildren */); #endif // GPOS_DEBUG // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerStatsBound::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerStatsBound::StartElement ( const XMLCh* const,// xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const,// xmlszQname, const Attributes& attrs ) { if(0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenStatsBucketLowerBound), xmlszLocalname) || 0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenStatsBucketUpperBound), xmlszLocalname)) { GPOS_ASSERT(NULL == m_pdxldatum); // translate the datum and add it to the datum array CDXLDatum *pdxldatum = CDXLOperatorFactory::Pdxldatum(m_pphm->Pmm(), attrs, EdxltokenDatum); m_pdxldatum = pdxldatum; if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenStatsBucketLowerBound), xmlszLocalname)) { m_fStatsBoundClosed = CDXLOperatorFactory::FValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenStatsBoundClosed, EdxltokenStatsBucketLowerBound); } else { m_fStatsBoundClosed = CDXLOperatorFactory::FValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenStatsBoundClosed, EdxltokenStatsBucketUpperBound); } } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerHint::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerHint::StartElement ( const XMLCh* const , //xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const , //xmlszQname, const Attributes& attrs ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenHint), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // parse hint configuration options ULONG ulMinNumOfPartsToRequireSortOnInsert = CDXLOperatorFactory::UlValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenMinNumOfPartsToRequireSortOnInsert, EdxltokenHint); ULONG ulJoinArityForAssociativityCommutativity = CDXLOperatorFactory::UlValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenJoinArityForAssociativityCommutativity, EdxltokenHint, true, INT_MAX); ULONG ulArrayExpansionThreshold = CDXLOperatorFactory::UlValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenArrayExpansionThreshold, EdxltokenHint, true, INT_MAX); ULONG ulJoinOrderDPThreshold = CDXLOperatorFactory::UlValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenJoinOrderDPThreshold, EdxltokenHint, true, JOIN_ORDER_DP_THRESHOLD); ULONG ulBroadcastThreshold = CDXLOperatorFactory::UlValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenBroadcastThreshold, EdxltokenHint, true, BROADCAST_THRESHOLD); ULONG fEnforceConstraintsOnDML = CDXLOperatorFactory::FValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenEnforceConstraintsOnDML, EdxltokenHint, true, true); m_phint = GPOS_NEW(m_pmp) CHint ( ulMinNumOfPartsToRequireSortOnInsert, ulJoinArityForAssociativityCommutativity, ulArrayExpansionThreshold, ulJoinOrderDPThreshold, ulBroadcastThreshold, fEnforceConstraintsOnDML ); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerSearchStrategy::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerSearchStrategy::StartElement ( const XMLCh* const xmlstrUri, const XMLCh* const xmlstrLocalname, const XMLCh* const xmlstrQname, const Attributes& attrs ) { if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenSearchStrategy), xmlstrLocalname)) { m_pdrgpss = GPOS_NEW(m_pmp) DrgPss(m_pmp); } else if(0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenSearchStage), xmlstrLocalname)) { GPOS_ASSERT(NULL != m_pdrgpss); // start new search stage CParseHandlerBase *pphSearchStage = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenSearchStage), m_pphm, this); m_pphm->ActivateParseHandler(pphSearchStage); // store parse handler this->Append(pphSearchStage); pphSearchStage->startElement(xmlstrUri, xmlstrLocalname, xmlstrQname, attrs); } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlstrLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerSearchStrategy::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerSearchStrategy::EndElement ( const XMLCh* const, // xmlstrUri, const XMLCh* const xmlstrLocalname, const XMLCh* const // xmlstrQname ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenSearchStrategy), xmlstrLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlstrLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } const ULONG ulSize = this->UlLength(); for (ULONG ul = 0; ul < ulSize; ul++) { CParseHandlerSearchStage *pphSearchStage = dynamic_cast<CParseHandlerSearchStage*>((*this)[ul]); CXformSet *pxfs = pphSearchStage->Pxfs(); pxfs->AddRef(); CSearchStage *pss = GPOS_NEW(m_pmp) CSearchStage(pxfs, pphSearchStage->UlTimeThreshold(), pphSearchStage->CostThreshold()); m_pdrgpss->Append(pss); } // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerDistinctComp::StartElement // // @doc: // Processes a Xerces start element event // //--------------------------------------------------------------------------- void CParseHandlerDistinctComp::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes& attrs ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarDistinctComp), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // parse and create distinct operator m_pdxlop = (CDXLScalarDistinctComp *) CDXLOperatorFactory::PdxlopDistinctCmp(m_pphm->Pmm(), attrs); // create and activate the parse handler for the children nodes in reverse // order of their expected appearance // parse handler for right scalar node CParseHandlerBase *pphRight = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalar), m_pphm, this); m_pphm->ActivateParseHandler(pphRight); // parse handler for left scalar node CParseHandlerBase *pphLeft = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalar), m_pphm, this); m_pphm->ActivateParseHandler(pphLeft); // store parse handlers this->Append(pphLeft); this->Append(pphRight); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarSwitchCase::StartElement // // @doc: // Processes a Xerces start element event // //--------------------------------------------------------------------------- void CParseHandlerScalarSwitchCase::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname, const Attributes& // attrs ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarSwitchCase), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // create and activate the parse handler for the children nodes in reverse // order of their expected appearance // parse handler for result expression CParseHandlerBase *pphResult = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalar), m_pphm, this); m_pphm->ActivateParseHandler(pphResult); // parse handler for condition expression CParseHandlerBase *pphCond = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalar), m_pphm, this); m_pphm->ActivateParseHandler(pphCond); // store parse handlers this->Append(pphCond); this->Append(pphResult); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarSwitchCase::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerScalarSwitchCase::EndElement ( const XMLCh* const ,// xmlszUri const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarSwitchCase), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // construct node m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, GPOS_NEW(m_pmp) CDXLScalarSwitchCase(m_pmp)); CParseHandlerScalarOp *pphCond = dynamic_cast<CParseHandlerScalarOp *>((*this)[0]); CParseHandlerScalarOp *pphResult = dynamic_cast<CParseHandlerScalarOp *>((*this)[1]); // add constructed children AddChildFromParseHandler(pphCond); AddChildFromParseHandler(pphResult); // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerAssert::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerAssert::StartElement ( const XMLCh* const , // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const , // xmlszQname, const Attributes& attrs ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenPhysicalAssert), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } CHAR *szErrorCode = CDXLOperatorFactory::SzValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenErrorCode, EdxltokenPhysicalAssert); if (NULL == szErrorCode || GPOS_SQLSTATE_LENGTH != clib::UlStrLen(szErrorCode)) { GPOS_RAISE ( gpdxl::ExmaDXL, gpdxl::ExmiDXLInvalidAttributeValue, CDXLTokens::PstrToken(EdxltokenPhysicalAssert)->Wsz(), CDXLTokens::PstrToken(EdxltokenErrorCode)->Wsz() ); } m_pdxlop = GPOS_NEW(m_pmp) CDXLPhysicalAssert(m_pmp, szErrorCode); // ctor created a copy of the error code GPOS_DELETE_ARRAY(szErrorCode); // parse handler for child node CParseHandlerBase *pphChild = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenPhysical), m_pphm, this); m_pphm->ActivateParseHandler(pphChild); // parse handler for the predicate CParseHandlerBase *pphAssertPredicate = CParseHandlerFactory::Pph ( m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarAssertConstraintList), m_pphm, this ); m_pphm->ActivateParseHandler(pphAssertPredicate); // parse handler for the proj list CParseHandlerBase *pphPrL = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarProjList), m_pphm, this); m_pphm->ActivateParseHandler(pphPrL); //parse handler for the properties of the operator CParseHandlerBase *pphProp = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenProperties), m_pphm, this); m_pphm->ActivateParseHandler(pphProp); this->Append(pphProp); this->Append(pphPrL); this->Append(pphAssertPredicate); this->Append(pphChild); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerIndexScan::EndElementHelper // // @doc: // Common EndElement functionality for IndexScan and IndexOnlyScan // //--------------------------------------------------------------------------- void CParseHandlerIndexScan::EndElementHelper ( const XMLCh* const xmlszLocalname, Edxltoken edxltoken, ULONG ulPartIndexId, ULONG ulPartIndexIdPrintable ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(edxltoken), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // construct node from the created child nodes CParseHandlerProperties *pphProp = dynamic_cast<CParseHandlerProperties *>((*this)[0]); CParseHandlerProjList *pphPrL = dynamic_cast<CParseHandlerProjList*>((*this)[1]); CParseHandlerFilter *pphFilter = dynamic_cast<CParseHandlerFilter *>((*this)[2]); CParseHandlerIndexCondList *pphIdxCondList = dynamic_cast<CParseHandlerIndexCondList *>((*this)[3]); CParseHandlerIndexDescr *pphIdxD = dynamic_cast<CParseHandlerIndexDescr *>((*this)[4]); CParseHandlerTableDescr *pphTD = dynamic_cast<CParseHandlerTableDescr *>((*this)[5]); CDXLTableDescr *pdxltabdesc = pphTD->Pdxltabdesc(); pdxltabdesc->AddRef(); CDXLIndexDescr *pdxlid = pphIdxD->Pdxlid(); pdxlid->AddRef(); CDXLPhysical *pdxlop = NULL; if (EdxltokenPhysicalIndexOnlyScan == edxltoken) { pdxlop = GPOS_NEW(m_pmp) CDXLPhysicalIndexOnlyScan(m_pmp, pdxltabdesc, pdxlid, m_edxlisd); m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop); } else if (EdxltokenPhysicalIndexScan == edxltoken) { pdxlop = GPOS_NEW(m_pmp) CDXLPhysicalIndexScan(m_pmp, pdxltabdesc, pdxlid, m_edxlisd); m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop); } else { GPOS_ASSERT(EdxltokenPhysicalDynamicIndexScan == edxltoken); pdxlop = GPOS_NEW(m_pmp) CDXLPhysicalDynamicIndexScan(m_pmp, pdxltabdesc, ulPartIndexId, ulPartIndexIdPrintable, pdxlid, m_edxlisd); m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop); } // set statistics and physical properties CParseHandlerUtils::SetProperties(m_pdxln, pphProp); // add children AddChildFromParseHandler(pphPrL); AddChildFromParseHandler(pphFilter); AddChildFromParseHandler(pphIdxCondList); // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerHashJoin::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerHashJoin::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes& attrs ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenPhysicalHashJoin), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // parse and create Hash join operator m_pdxlop = (CDXLPhysicalHashJoin *) CDXLOperatorFactory::PdxlopHashJoin(m_pphm->Pmm(), attrs); // create and activate the parse handler for the children nodes in reverse // order of their expected appearance // parse handler for right child CParseHandlerBase *pphRight = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenPhysical), m_pphm, this); m_pphm->ActivateParseHandler(pphRight); // parse handler for left child CParseHandlerBase *pphLeft = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenPhysical), m_pphm, this); m_pphm->ActivateParseHandler(pphLeft); // parse handler for the hash clauses CParseHandlerBase *pphHashCondList = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarHashCondList), m_pphm, this); m_pphm->ActivateParseHandler(pphHashCondList); // parse handler for the join filter CParseHandlerBase *ppHJFilter = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarFilter), m_pphm, this); m_pphm->ActivateParseHandler(ppHJFilter); // parse handler for the filter CParseHandlerBase *pphFilter = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarFilter), m_pphm, this); m_pphm->ActivateParseHandler(pphFilter); // parse handler for the proj list CParseHandlerBase *pphPrL = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarProjList), m_pphm, this); m_pphm->ActivateParseHandler(pphPrL); //parse handler for the properties of the operator CParseHandlerBase *pphProp = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenProperties), m_pphm, this); m_pphm->ActivateParseHandler(pphProp); // store parse handlers this->Append(pphProp); this->Append(pphPrL); this->Append(pphFilter); this->Append(ppHJFilter); this->Append(pphHashCondList); this->Append(pphLeft); this->Append(pphRight); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerPhysicalSplit::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerPhysicalSplit::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes &attrs ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenPhysicalSplit), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } const XMLCh *xmlszDeleteColIds = CDXLOperatorFactory::XmlstrFromAttrs(attrs, EdxltokenDeleteCols, EdxltokenPhysicalSplit); m_pdrgpulDelete = CDXLOperatorFactory::PdrgpulFromXMLCh(m_pphm->Pmm(), xmlszDeleteColIds, EdxltokenDeleteCols, EdxltokenPhysicalSplit); const XMLCh *xmlszInsertColIds = CDXLOperatorFactory::XmlstrFromAttrs(attrs, EdxltokenInsertCols, EdxltokenPhysicalSplit); m_pdrgpulInsert = CDXLOperatorFactory::PdrgpulFromXMLCh(m_pphm->Pmm(), xmlszInsertColIds, EdxltokenInsertCols, EdxltokenPhysicalSplit); m_ulAction = CDXLOperatorFactory::UlValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenActionColId, EdxltokenPhysicalSplit); m_ulCtid = CDXLOperatorFactory::UlValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenCtidColId, EdxltokenPhysicalSplit); m_ulSegmentId = CDXLOperatorFactory::UlValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenGpSegmentIdColId, EdxltokenPhysicalSplit); const XMLCh *xmlszPreserveOids = attrs.getValue(CDXLTokens::XmlstrToken(EdxltokenUpdatePreservesOids)); if (NULL != xmlszPreserveOids) { m_fPreserveOids = CDXLOperatorFactory::FValueFromXmlstr ( m_pphm->Pmm(), xmlszPreserveOids, EdxltokenUpdatePreservesOids, EdxltokenPhysicalSplit ); } if (m_fPreserveOids) { m_ulTupleOidColId = CDXLOperatorFactory::UlValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenTupleOidColId, EdxltokenPhysicalSplit); } // parse handler for physical operator CParseHandlerBase *pphChild = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenPhysical), m_pphm, this); m_pphm->ActivateParseHandler(pphChild); // parse handler for the proj list CParseHandlerBase *pphPrL = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarProjList), m_pphm, this); m_pphm->ActivateParseHandler(pphPrL); //parse handler for the properties of the operator CParseHandlerBase *pphProp = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenProperties), m_pphm, this); m_pphm->ActivateParseHandler(pphProp); // store child parse handlers in array this->Append(pphProp); this->Append(pphPrL); this->Append(pphChild); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerSort::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerSort::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes& attrs ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenPhysicalSort), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // parse and create Sort operator m_pdxlop = (CDXLPhysicalSort *) CDXLOperatorFactory::PdxlopSort(m_pphm->Pmm(), attrs); // create and activate the parse handler for the children nodes in reverse // order of their expected appearance // parse handler for the child CParseHandlerBase *pphChild = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenPhysical), m_pphm, this); m_pphm->ActivateParseHandler(pphChild); // create parse handlers for the limit count and offset expressions CParseHandlerBase *pphOffset = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarLimitOffset), m_pphm, this); m_pphm->ActivateParseHandler(pphOffset); CParseHandlerBase *pphCount = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarLimitCount), m_pphm, this); m_pphm->ActivateParseHandler(pphCount); // parse handler for the sorting column list CParseHandlerBase *pphSortColList = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarSortColList), m_pphm, this); m_pphm->ActivateParseHandler(pphSortColList); // parse handler for the filter CParseHandlerBase *pphFilter = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarFilter), m_pphm, this); m_pphm->ActivateParseHandler(pphFilter); // parse handler for the proj list CParseHandlerBase *pphPrL = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarProjList), m_pphm, this); m_pphm->ActivateParseHandler(pphPrL); //parse handler for the properties of the operator CParseHandlerBase *pphProp = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenProperties), m_pphm, this); m_pphm->ActivateParseHandler(pphProp); // store parse handlers this->Append(pphProp); this->Append(pphPrL); this->Append(pphFilter); this->Append(pphSortColList); this->Append(pphCount); this->Append(pphOffset); this->Append(pphChild); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerLogicalLimit::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerLogicalLimit::StartElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const, // element_qname const Attributes& attrs ) { if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenLogicalLimit), element_local_name)) { const XMLCh *non_removable_limit_str = attrs.getValue(CDXLTokens::XmlstrToken(EdxltokenTopLimitUnderDML)); BOOL keep_limit = false; if (non_removable_limit_str) { keep_limit = CDXLOperatorFactory::ConvertAttrValueToBool ( m_parse_handler_mgr->GetDXLMemoryManager(), non_removable_limit_str, EdxltokenTopLimitUnderDML, EdxltokenLogicalLimit ); } m_dxl_node = GPOS_NEW(m_mp) CDXLNode(m_mp, GPOS_NEW(m_mp) CDXLLogicalLimit(m_mp, keep_limit)); // create child node parsers // parse handler for logical operator CParseHandlerBase *child_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenLogical), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(child_parse_handler); CParseHandlerBase *offset_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenScalarLimitOffset), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(offset_parse_handler); CParseHandlerBase *count_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenScalarLimitCount), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(count_parse_handler); // parse handler for the sorting column list CParseHandlerBase *sort_col_list_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenScalarSortColList), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(sort_col_list_parse_handler); // store child parse handler in array this->Append(sort_col_list_parse_handler); this->Append(count_parse_handler); this->Append(offset_parse_handler); this->Append(child_parse_handler); } else { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarOp::EndElement // // @doc: // Invoked by Xerces to process a closing tag. // This function should never be called. Instead, the endElement function // of the parse handler for the actual physical operator type is called. // //--------------------------------------------------------------------------- void CParseHandlerScalarOp::EndElement ( const XMLCh* const, //= xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname, ) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerMDGPDBScalarOp::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerMDGPDBScalarOp::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenGPDBScalarOp), xmlszLocalname)) { // construct the MD scalar operator object from its part GPOS_ASSERT(m_pmdid->FValid() && NULL != m_pmdname); GPOS_ASSERT(0 == this->UlLength() || 1 == this->UlLength()); DrgPmdid *pdrgpmdidOpClasses = NULL; if (0 < this->UlLength()) { CParseHandlerMetadataIdList *pphMdidOpClasses = dynamic_cast<CParseHandlerMetadataIdList*>((*this)[0]); pdrgpmdidOpClasses = pphMdidOpClasses->Pdrgpmdid(); pdrgpmdidOpClasses->AddRef(); } else { pdrgpmdidOpClasses = GPOS_NEW(m_pmp) DrgPmdid(m_pmp); } m_pimdobj = GPOS_NEW(m_pmp) CMDScalarOpGPDB ( m_pmp, m_pmdid, m_pmdname, m_pmdidTypeLeft, m_pmdidTypeRight, m_pmdidTypeResult, m_pmdidFunc, m_pmdidOpCommute, m_pmdidOpInverse, m_ecmpt, m_fReturnsNullOnNullInput, pdrgpmdidOpClasses ) ; // deactivate handler m_pphm->DeactivateHandler(); } else if (!FSupportedChildElem(xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerLogicalUpdate::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerLogicalUpdate::StartElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const, // element_qname const Attributes &attrs ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenLogicalUpdate), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } m_ctid_colid = CDXLOperatorFactory::ExtractConvertAttrValueToUlong(m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenCtidColId, EdxltokenLogicalUpdate); m_segid_colid = CDXLOperatorFactory::ExtractConvertAttrValueToUlong(m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenGpSegmentIdColId, EdxltokenLogicalUpdate); const XMLCh *delete_colids_xml = CDXLOperatorFactory::ExtractAttrValue(attrs, EdxltokenDeleteCols, EdxltokenLogicalUpdate); m_deletion_colid_array = CDXLOperatorFactory::ExtractIntsToUlongArray(m_parse_handler_mgr->GetDXLMemoryManager(), delete_colids_xml, EdxltokenDeleteCols, EdxltokenLogicalUpdate); const XMLCh *insert_colids_xml = CDXLOperatorFactory::ExtractAttrValue(attrs, EdxltokenInsertCols, EdxltokenLogicalUpdate); m_insert_colid_array = CDXLOperatorFactory::ExtractIntsToUlongArray(m_parse_handler_mgr->GetDXLMemoryManager(), insert_colids_xml, EdxltokenInsertCols, EdxltokenLogicalUpdate); const XMLCh *preserve_oids_xml = attrs.getValue(CDXLTokens::XmlstrToken(EdxltokenUpdatePreservesOids)); if (NULL != preserve_oids_xml) { m_preserve_oids = CDXLOperatorFactory::ConvertAttrValueToBool ( m_parse_handler_mgr->GetDXLMemoryManager(), preserve_oids_xml, EdxltokenUpdatePreservesOids, EdxltokenLogicalUpdate ); } if (m_preserve_oids) { m_tuple_oid_col_oid = CDXLOperatorFactory::ExtractConvertAttrValueToUlong(m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenTupleOidColId, EdxltokenLogicalUpdate); } // parse handler for logical operator CParseHandlerBase *child_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenLogical), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(child_parse_handler); //parse handler for the table descriptor CParseHandlerBase *table_descr_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenTableDescr), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(table_descr_parse_handler); // store child parse handler in array this->Append(table_descr_parse_handler); this->Append(child_parse_handler); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerPhysicalDML::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerPhysicalDML::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { EdxlDmlType edxldmltype = CParseHandlerPhysicalDML::EdxlDmlOpType(xmlszLocalname); if (EdxldmlSentinel == edxldmltype || m_edxldmltype != edxldmltype) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } GPOS_ASSERT(5 == this->UlLength()); CParseHandlerProperties *pphProp = dynamic_cast<CParseHandlerProperties *>((*this)[0]); GPOS_ASSERT(NULL != pphProp->Pdxlprop()); CParseHandlerDirectDispatchInfo *pphDirectDispatch = dynamic_cast<CParseHandlerDirectDispatchInfo *>((*this)[1]); GPOS_ASSERT(NULL != pphDirectDispatch->Pdxlddinfo() && NULL != pphDirectDispatch->Pdxlddinfo()); CParseHandlerProjList *pphPrL = dynamic_cast<CParseHandlerProjList*>((*this)[2]); GPOS_ASSERT(NULL != pphPrL->Pdxln()); CParseHandlerTableDescr *pphTabDesc = dynamic_cast<CParseHandlerTableDescr*>((*this)[3]); GPOS_ASSERT(NULL != pphTabDesc->Pdxltabdesc()); CDXLTableDescr *pdxltabdesc = pphTabDesc->Pdxltabdesc(); pdxltabdesc->AddRef(); CParseHandlerPhysicalOp *pphChild = dynamic_cast<CParseHandlerPhysicalOp*>((*this)[4]); GPOS_ASSERT(NULL != pphChild->Pdxln()); CDXLDirectDispatchInfo *pdxlddinfo = pphDirectDispatch->Pdxlddinfo(); pdxlddinfo->AddRef(); CDXLPhysicalDML *pdxlop = GPOS_NEW(m_pmp) CDXLPhysicalDML(m_pmp, m_edxldmltype, pdxltabdesc, m_pdrgpul, m_ulAction, m_ulOid, m_ulCtid, m_ulSegmentId, m_fPreserveOids, m_ulTupleOidColId, pdxlddinfo, m_fInputSorted); m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop); // set statistics and physical properties CParseHandlerUtils::SetProperties(m_pdxln, pphProp); AddChildFromParseHandler(pphPrL); AddChildFromParseHandler(pphChild); #ifdef GPOS_DEBUG m_pdxln->Pdxlop()->AssertValid(m_pdxln, false /* fValidateChildren */); #endif // GPOS_DEBUG // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerPhysicalSplit::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerPhysicalSplit::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenPhysicalSplit), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } GPOS_ASSERT(3 == this->UlLength()); CParseHandlerProperties *pphProp = dynamic_cast<CParseHandlerProperties *>((*this)[0]); CParseHandlerProjList *pphPrL = dynamic_cast<CParseHandlerProjList*>((*this)[1]); GPOS_ASSERT(NULL != pphPrL->Pdxln()); CParseHandlerPhysicalOp *pphChild = dynamic_cast<CParseHandlerPhysicalOp*>((*this)[2]); GPOS_ASSERT(NULL != pphChild->Pdxln()); CDXLPhysicalSplit *pdxlop = GPOS_NEW(m_pmp) CDXLPhysicalSplit ( m_pmp, m_pdrgpulDelete, m_pdrgpulInsert, m_ulAction, m_ulCtid, m_ulSegmentId, m_fPreserveOids, m_ulTupleOidColId ); m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop); // set statistics and physical properties CParseHandlerUtils::SetProperties(m_pdxln, pphProp); AddChildFromParseHandler(pphPrL); AddChildFromParseHandler(pphChild); #ifdef GPOS_DEBUG m_pdxln->Pdxlop()->AssertValid(m_pdxln, false /* fValidateChildren */); #endif // GPOS_DEBUG // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerTest::EresParseAndSerializeMetadata // // @doc: // Verifies that after parsing the given DXL file containing metadata into // a list of metadata objects, which should be serialized back to the same string. // //--------------------------------------------------------------------------- GPOS_RESULT CParseHandlerTest::EresParseAndSerializeMetadata ( IMemoryPool *pmp, const CHAR *szDXLFileName, BOOL fValidate ) { CWStringDynamic str(pmp); COstreamString oss(&str); // read DXL file CHAR *szDXL = CDXLUtils::SzRead(pmp, szDXLFileName); GPOS_CHECK_ABORT; // parse the metadata objects into a dynamic array const CHAR *szValidationPath = NULL; if (fValidate) { szValidationPath = CTestUtils::m_szXSDPath; } DrgPimdobj *pdrgpmdobj = CDXLUtils::PdrgpmdobjParseDXL(pmp, szDXL, szValidationPath); GPOS_ASSERT(NULL != pdrgpmdobj); GPOS_CHECK_ABORT; oss << "Serializing metadata objects" << std::endl; CWStringDynamic *pstr = CDXLUtils::PstrSerializeMetadata(pmp, pdrgpmdobj, true /*fSerializeHeaderFooter*/, true /*fIndent*/); GPOS_CHECK_ABORT; CWStringDynamic dstrExpected(pmp); dstrExpected.AppendFormat(GPOS_WSZ_LIT("%s"), szDXL); if (!dstrExpected.FEquals(pstr)) { GPOS_TRACE(pstr->Wsz()); GPOS_ASSERT(false); } pdrgpmdobj->Release(); GPOS_DELETE(pstr); GPOS_DELETE_ARRAY(szDXL); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CParseHandlerAgg::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerAgg::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes& attrs ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenPhysicalAggregate), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // parse and create group by operator m_pdxlop = (CDXLPhysicalAgg *) CDXLOperatorFactory::PdxlopAgg(m_pphm->Pmm(), attrs); // create and activate the parse handler for the children nodes in reverse // order of their expected appearance // parse handler for child node CParseHandlerBase *pphChild = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenPhysical), m_pphm, this); m_pphm->ActivateParseHandler(pphChild); // parse handler for the filter CParseHandlerBase *pphFilter = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarFilter), m_pphm, this); m_pphm->ActivateParseHandler(pphFilter); // parse handler for the proj list CParseHandlerBase *pphPrL = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarProjList), m_pphm, this); m_pphm->ActivateParseHandler(pphPrL); //parse handler for the grouping columns list CParseHandlerBase *pphGrpColList = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarGroupingColList), m_pphm, this); m_pphm->ActivateParseHandler(pphGrpColList); //parse handler for the properties of the operator CParseHandlerBase *pphProp = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenProperties), m_pphm, this); m_pphm->ActivateParseHandler(pphProp); // store parse handlers this->Append(pphProp); this->Append(pphGrpColList); this->Append(pphPrL); this->Append(pphFilter); this->Append(pphChild); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerLogicalConstTable::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerLogicalConstTable::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname, const Attributes& attrs ) { if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenLogicalConstTable), xmlszLocalname)) { // start of a const table operator node GPOS_ASSERT(0 == this->UlLength()); GPOS_ASSERT(NULL == m_pdrgpdrgpdxldatum); // initialize the array of const tuples (datum arrays) m_pdrgpdrgpdxldatum = GPOS_NEW(m_pmp) DrgPdrgPdxldatum(m_pmp); // install a parse handler for the columns CParseHandlerBase *pphColDescr = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenColumns), m_pphm, this); m_pphm->ActivateParseHandler(pphColDescr); // store parse handler this->Append(pphColDescr); } else if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenConstTuple), xmlszLocalname)) { GPOS_ASSERT(NULL != m_pdrgpdrgpdxldatum); // we must have already seen a logical const table GPOS_ASSERT(NULL == m_pdrgpdxldatum); // initialize the array of datums (const tuple) m_pdrgpdxldatum = GPOS_NEW(m_pmp) DrgPdxldatum(m_pmp); } else if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenDatum), xmlszLocalname)) { // we must have already seen a logical const table and a const tuple GPOS_ASSERT(NULL != m_pdrgpdrgpdxldatum); GPOS_ASSERT(NULL != m_pdrgpdxldatum); // translate the datum and add it to the datum array CDXLDatum *pdxldatum = CDXLOperatorFactory::Pdxldatum(m_pphm->Pmm(), attrs, EdxltokenScalarConstValue); m_pdrgpdxldatum->Append(pdxldatum); } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerTest::EresParseAndSerializeScalarExpr // // @doc: // Parses a ScalarExpr and verifies that the serialization is identical // to the original input. // //--------------------------------------------------------------------------- GPOS_RESULT CParseHandlerTest::EresParseAndSerializeScalarExpr ( IMemoryPool *pmp, const CHAR *szDXLFileName, BOOL fValidate ) { // read DXL file CHAR *szDXL = CDXLUtils::SzRead(pmp, szDXLFileName); GPOS_CHECK_ABORT; const CHAR *szValidationPath = NULL; if (fValidate) { szValidationPath = CTestUtils::m_szXSDPath; } // the root of the parsed DXL tree CDXLNode *pdxlnRoot = CDXLUtils::PdxlnParseScalarExpr(pmp, szDXL, szValidationPath); GPOS_CHECK_ABORT; CWStringDynamic str(pmp); COstreamString oss(&str); oss << "Serializing parsed tree" << std::endl; CWStringDynamic *pstr = CDXLUtils::PstrSerializeScalarExpr(pmp, pdxlnRoot, true /*fSerializeHeaderFooter*/, true /*fIndent*/); GPOS_CHECK_ABORT; CWStringDynamic dstrExpected(pmp); dstrExpected.AppendFormat(GPOS_WSZ_LIT("%s"), szDXL); GPOS_RESULT eres = GPOS_OK; if (!dstrExpected.FEquals(pstr)) { GPOS_TRACE(dstrExpected.Wsz()); GPOS_TRACE(pstr->Wsz()); GPOS_ASSERT(!"Not matching"); eres = GPOS_FAILED; } // cleanup pdxlnRoot->Release(); GPOS_DELETE(pstr); GPOS_DELETE_ARRAY(szDXL); return eres; }
//--------------------------------------------------------------------------- // @function: // CDXLUtilsTest::EresUnittest_SerializeQuery // // @doc: // Testing serialization of queries in DXL // //--------------------------------------------------------------------------- GPOS_RESULT CDXLUtilsTest::EresUnittest_SerializeQuery() { // create memory pool CAutoMemoryPool amp; IMemoryPool *pmp = amp.Pmp(); // read DXL file CHAR *szDXL = CDXLUtils::SzRead(pmp, szQueryFile); CQueryToDXLResult *presult = CDXLUtils::PdxlnParseDXLQuery(pmp, szDXL, NULL /*szXSDPath*/); // serialize with document header BOOL rgfIndentation[] = {true, false}; BOOL rgfHeaders[] = {true, false}; CWStringDynamic str(pmp); COstreamString oss(&str); for (ULONG ulHeaders = 0; ulHeaders < GPOS_ARRAY_SIZE(rgfHeaders); ulHeaders++) { for (ULONG ulIndent = 0; ulIndent < GPOS_ARRAY_SIZE(rgfIndentation); ulIndent++) { CWStringDynamic *pstr = CDXLUtils::PstrSerializeQuery ( pmp, presult->Pdxln(), presult->PdrgpdxlnOutputCols(), presult->PdrgpdxlnCTE(), rgfHeaders[ulHeaders], rgfIndentation[ulIndent] ); oss << "Headers: " << rgfHeaders[ulHeaders] << ", indentation: " << rgfIndentation[ulIndent] << std::endl; oss << pstr->Wsz() << std::endl; GPOS_DELETE(pstr); } } GPOS_TRACE(str.Wsz()); // cleanup GPOS_DELETE(presult); GPOS_DELETE_ARRAY(szDXL); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CColumnFactory::PcrCreate // // @doc: // Variant without name for computed columns // //--------------------------------------------------------------------------- CColRef * CColumnFactory::PcrCreate ( const IMDType *pmdtype ) { // increment atomic counter ULONG ulId = m_aul.TIncr(); WCHAR wszFmt[] = GPOS_WSZ_LIT("ColRef_%04d"); CWStringDynamic *pstrTempName = GPOS_NEW(m_pmp) CWStringDynamic(m_pmp); CAutoP<CWStringDynamic> a_pstrTempName(pstrTempName); pstrTempName->AppendFormat(wszFmt, ulId); CWStringConst strName(pstrTempName->Wsz()); return PcrCreate(pmdtype, ulId, CName(&strName)); }