//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarCoerceToDomain::StartElement // // @doc: // Processes a Xerces start element event // //--------------------------------------------------------------------------- void CParseHandlerScalarCoerceToDomain::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes& attrs ) { if(0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarCoerceToDomain), xmlszLocalname)) { if (NULL != m_pdxln) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // parse and create scalar coerce CDXLScalarCoerceToDomain *pdxlop = (CDXLScalarCoerceToDomain*) CDXLOperatorFactory::PdxlopCoerceToDomain(m_pphm->Pmm(), attrs); m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop); // parse handler for child scalar node CParseHandlerBase *pphChild = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalar), m_pphm, this); m_pphm->ActivateParseHandler(pphChild); // store parse handler this->Append(pphChild); } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerResult::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerResult::StartElement ( const XMLCh* const xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const xmlszQname, const Attributes& attrs ) { if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenPhysicalResult), xmlszLocalname) && NULL == m_pdxlop) { SetupInitialHandlers(); } else if (NULL != m_pdxlop) { // parse handler for child node CParseHandlerBase *pphChild = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenPhysical), m_pphm, this); m_pphm->ActivateParseHandler(pphChild); this->Append(pphChild); pphChild->startElement(xmlszUri, xmlszLocalname, xmlszQname, attrs); } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerProjElem::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerProjElem::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes& attrs ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarProjElem), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // parse and create proj elem operator m_pdxlop = (CDXLScalarProjElem *) CDXLOperatorFactory::PdxlopProjElem(m_pphm->Pmm(), attrs); // create and activate the parse handler for the child scalar expression node CParseHandlerBase *pph = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalar), m_pphm, this); m_pphm->ActivateParseHandler(pph); // store parse handler this->Append(pph); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerSortColList::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerSortColList::StartElement ( const XMLCh* const xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const xmlszQname, const Attributes& attrs ) { if(0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarSortColList), xmlszLocalname)) { // start the sorting column list m_pdxln = GPOS_NEW(m_pmp) CDXLNode (m_pmp, GPOS_NEW(m_pmp) CDXLScalarSortColList(m_pmp)); } else if(0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarSortCol), xmlszLocalname)) { // we must have seen a sorting col list already and initialized the sort col list node GPOS_ASSERT(NULL != m_pdxln); // start new sort column CParseHandlerBase *pphSortCol = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenScalarSortCol), m_pphm, this); m_pphm->ActivateParseHandler(pphSortCol); // store parse handler this->Append(pphSortCol); pphSortCol->startElement(xmlszUri, xmlszLocalname, xmlszQname, attrs); } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarSwitch::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerScalarSwitch::EndElement ( const XMLCh* const ,// xmlszUri const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarSwitch), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } const ULONG ulChildren = this->UlLength(); GPOS_ASSERT(1 < ulChildren); for (ULONG ul = 0; ul < ulChildren ; ul++) { CParseHandlerScalarOp *pphChild = dynamic_cast<CParseHandlerScalarOp *>((*this)[ul]); AddChildFromParseHandler(pphChild); } // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarSubPlanTestExpr::EndElement // // @doc: // Processes a Xerces end element event // //--------------------------------------------------------------------------- void CParseHandlerScalarSubPlanTestExpr::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarSubPlanTestExpr), xmlszLocalname) && NULL != m_pdxlnTestExpr) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } if (0 < this->UlLength()) { CParseHandlerScalarOp *pphChild = dynamic_cast<CParseHandlerScalarOp *>((*this)[0]); if (NULL != pphChild->Pdxln()) { m_pdxlnTestExpr = pphChild->Pdxln(); m_pdxlnTestExpr->AddRef(); } } // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarNullTest::EndElement // // @doc: // Processes a Xerces end element event // //--------------------------------------------------------------------------- void CParseHandlerScalarNullTest::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if ((0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarIsNull), xmlszLocalname)) && (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarIsNotNull), xmlszLocalname))) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } GPOS_ASSERT(1 == this->UlLength()); // add constructed child from child parse handler CParseHandlerScalarOp *pphChild = dynamic_cast<CParseHandlerScalarOp*>((*this)[0]); AddChildFromParseHandler(pphChild); // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerWindowSpecList::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerWindowSpecList::StartElement ( const XMLCh* const xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const xmlszQname, const Attributes& attrs ) { if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenWindowSpecList), xmlszLocalname)) { m_pdrgpdxlws = GPOS_NEW(m_pmp) DrgPdxlws(m_pmp); } else if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenWindowSpec), xmlszLocalname)) { // we must have seen a window specification list already GPOS_ASSERT(NULL != m_pdrgpdxlws); // start new window specification element CParseHandlerBase *pphWs = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenWindowSpec), m_pphm, this); m_pphm->ActivateParseHandler(pphWs); // store parse handler this->Append(pphWs); pphWs->startElement(xmlszUri, xmlszLocalname, xmlszQname, attrs); } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerPhysicalCTEProducer::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerPhysicalCTEProducer::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenPhysicalCTEProducer), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } GPOS_ASSERT(NULL != m_pdxln); CParseHandlerProperties *pphProp = dynamic_cast<CParseHandlerProperties *>((*this)[0]); CParseHandlerProjList *pphPrL = dynamic_cast<CParseHandlerProjList*>((*this)[1]); CParseHandlerPhysicalOp *pphChild = dynamic_cast<CParseHandlerPhysicalOp *>((*this)[2]); // set physical properties CParseHandlerUtils::SetProperties(m_pdxln, pphProp); // add constructed children AddChildFromParseHandler(pphPrL); AddChildFromParseHandler(pphChild); #ifdef GPOS_DEBUG m_pdxln->Pdxlop()->AssertValid(m_pdxln, false /* fValidateChildren */); #endif // GPOS_DEBUG m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerColStatsBucket::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerColStatsBucket::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenColumnStatsBucket), xmlszLocalname)) { m_pdxlbucket = GPOS_NEW(m_pmp) CDXLBucket(m_pdxldatumLower, m_pdxldatumUpper, m_fLowerClosed, m_fUpperClosed, m_dFrequency, m_dDistinct); // deactivate handler m_pphm->DeactivateHandler(); } else if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenStatsBucketLowerBound), xmlszLocalname) && 0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenStatsBucketUpperBound), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE ( gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz() ); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarBitmapIndexProbe::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerScalarBitmapIndexProbe::EndElement ( const XMLCh* const, // xmlszUri const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if (0 != XMLString::compareString ( CDXLTokens::XmlstrToken(EdxltokenScalarBitmapIndexProbe), xmlszLocalname )) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // construct node from the created child nodes CParseHandlerIndexCondList *pphIdxCondList = dynamic_cast<CParseHandlerIndexCondList *>((*this)[0]); CParseHandlerIndexDescr *pphIdxD = dynamic_cast<CParseHandlerIndexDescr *>((*this)[1]); CDXLIndexDescr *pdxlid = pphIdxD->Pdxlid(); pdxlid->AddRef(); CDXLScalar *pdxlop = GPOS_NEW(m_pmp) CDXLScalarBitmapIndexProbe(m_pmp, pdxlid); m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop); // add children AddChildFromParseHandler(pphIdxCondList); // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerMetadataIdList::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerMetadataIdList::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenTriggers), xmlszLocalname) || 0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenPartitions), xmlszLocalname)|| 0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenCheckConstraints), xmlszLocalname) || 0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenOpClasses), xmlszLocalname)) { // end the index or partition metadata id list GPOS_ASSERT(NULL != m_pdrgpmdid); // deactivate handler m_pphm->DeactivateHandler(); } else if (!FSupportedElem(xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarComp::StartElement // // @doc: // Processes a Xerces start element event // //--------------------------------------------------------------------------- void CParseHandlerScalarComp::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes& attrs ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarComp), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // parse and create comparison operator m_pdxlop = (CDXLScalarComp *) CDXLOperatorFactory::PdxlopScalarCmp(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: // CParseHandlerScalarSubPlanParamList::EndElement // // @doc: // Processes a Xerces end element event // //--------------------------------------------------------------------------- void CParseHandlerScalarSubPlanParamList::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarSubPlanParamList), xmlszLocalname) && NULL != m_pdxln) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } const ULONG ulSize = this->UlLength(); // add constructed children from child parse handlers for (ULONG ul = 0; ul < ulSize; ul++) { CParseHandlerScalarSubPlanParam *pphParam = dynamic_cast<CParseHandlerScalarSubPlanParam *>((*this)[ul]); CDXLColRef *pdxlcr = pphParam->Pdxlcr(); IMDId *pmdid = pphParam->Pmdid(); pdxlcr->AddRef(); pmdid->AddRef(); m_pdrgdxlcr->Append(pdxlcr); m_pdrgmdid->Append(pmdid); } // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarSubqueryExists::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerScalarSubqueryExists::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes& // attrs ) { GPOS_ASSERT(NULL == m_pdxlop); if(0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarSubqueryExists), xmlszLocalname)) { m_pdxlop = GPOS_NEW(m_pmp) CDXLScalarSubqueryExists(m_pmp); } else if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarSubqueryNotExists), xmlszLocalname)) { m_pdxlop = GPOS_NEW(m_pmp) CDXLScalarSubqueryNotExists(m_pmp); } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // parse handler for the child node CParseHandlerBase *pphChild = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenLogical), m_pphm, this); m_pphm->ActivateParseHandler(pphChild); // store child parse handler in array this->Append(pphChild); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerColDescr::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerColDescr::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes& attrs ) { if (0 == XMLString::compareString(xmlszLocalname, CDXLTokens::XmlstrToken(EdxltokenColumns))) { // start of the columns block GPOS_ASSERT(NULL == m_pdxlcd); } else if (0 == XMLString::compareString(xmlszLocalname, CDXLTokens::XmlstrToken(EdxltokenColumn))) { // start of a new column descriptor m_pdxlcd = CDXLOperatorFactory::Pdxlcd(m_pphm->Pmm(), attrs); } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerGroupingColList::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerGroupingColList::StartElement ( const XMLCh* const , //xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const , //xmlszQname, const Attributes& attrs ) { if(0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarGroupingColList), xmlszLocalname)) { // start the grouping column list m_pdrgpulGroupingCols = GPOS_NEW(m_pmp) DrgPul(m_pmp); } else if(0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenGroupingCol), xmlszLocalname)) { // we must have seen a grouping cols list already and initialized the grouping cols array GPOS_ASSERT(NULL != m_pdrgpulGroupingCols); // parse grouping col id ULONG *pulColId = GPOS_NEW(m_pmp) ULONG(CDXLOperatorFactory::UlGroupingColId(m_pphm->Pmm(), attrs)); m_pdrgpulGroupingCols->Append(pulColId); } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
// invoked by Xerces to process an opening tag void CParseHandlerScalarValuesList::StartElement ( const XMLCh* const xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const xmlszQname, const Attributes& attrs ) { if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarValuesList), xmlszLocalname)) { CDXLScalarValuesList *pdxlop = GPOS_NEW(m_pmp) CDXLScalarValuesList(m_pmp); m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, pdxlop); } else if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarConstValue), xmlszLocalname)) { CParseHandlerBase *pphScConstValue = CParseHandlerFactory::Pph(m_pmp, xmlszLocalname, m_pphm, this); m_pphm->ActivateParseHandler(pphScConstValue); this->Append(pphScConstValue); pphScConstValue->startElement(xmlszUri, xmlszLocalname, xmlszQname, attrs); } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerWindowSpecList::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerWindowSpecList::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenWindowSpecList), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } GPOS_ASSERT(NULL != m_pdrgpdxlws); const ULONG ulSize = this->UlLength(); // add the window specifications to the list for (ULONG ul = 0; ul < ulSize; ul++) { CParseHandlerWindowSpec *pphWs = dynamic_cast<CParseHandlerWindowSpec *>((*this)[ul]); m_pdrgpdxlws->Append(pphWs->Pdxlws()); } // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarSubqueryQuantified::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerScalarSubqueryQuantified::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarSubqueryAll), xmlszLocalname) && 0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarSubqueryAny), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // construct node from parsed components GPOS_ASSERT(NULL != m_pdxlop); GPOS_ASSERT(2 == this->UlLength()); CParseHandlerScalarOp *pphScChild = dynamic_cast<CParseHandlerScalarOp *>((*this)[0]); CParseHandlerLogicalOp *pphLgChild = dynamic_cast<CParseHandlerLogicalOp *>((*this)[1]); m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, m_pdxlop); // add constructed child AddChildFromParseHandler(pphScChild); AddChildFromParseHandler(pphLgChild); #ifdef GPOS_DEBUG m_pdxlop->AssertValid(m_pdxln, false /* fValidateChildren */); #endif // GPOS_DEBUG // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerCostModel::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerCostModel::StartElement ( const XMLCh* const , //xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const , //xmlszQname, const Attributes& attrs ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenCostModelConfig), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } ULONG ulSegments = CDXLOperatorFactory::UlValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenSegmentsForCosting, EdxltokenCostModelConfig); ICostModel::ECostModelType ecmt = (ICostModel::ECostModelType) CDXLOperatorFactory::UlValueFromAttrs(m_pphm->Pmm(), attrs, EdxltokenCostModelType, EdxltokenCostModelConfig); if (ICostModel::EcmtGPDBLegacy == ecmt) { m_pcm = GPOS_NEW(m_pmp) CCostModelGPDBLegacy(m_pmp, ulSegments); } else { GPOS_ASSERT(ICostModel::EcmtGPDBCalibrated == ecmt); m_pcm = GPOS_NEW(m_pmp) CCostModelGPDB(m_pmp, ulSegments); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerRoutedMotion::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerRoutedMotion::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenPhysicalRoutedDistributeMotion), 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]); CParseHandlerSortColList *pphSortColList = dynamic_cast<CParseHandlerSortColList *>((*this)[3]); CParseHandlerPhysicalOp *pphChild = dynamic_cast<CParseHandlerPhysicalOp *>((*this)[4]); m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, m_pdxlop); // set statictics and physical properties CParseHandlerUtils::SetProperties(m_pdxln, pphProp); // add children AddChildFromParseHandler(pphPrL); AddChildFromParseHandler(pphFilter); AddChildFromParseHandler(pphSortColList); AddChildFromParseHandler(pphChild); // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerTableDescr::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerTableDescr::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenTableDescr), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // construct node from the created child nodes GPOS_ASSERT(1 == this->UlLength()); // assemble the properties container from the cost CParseHandlerColDescr *pphColDescr = dynamic_cast<CParseHandlerColDescr *>((*this)[0]); GPOS_ASSERT(NULL != pphColDescr->Pdrgpdxlcd()); DrgPdxlcd *pdrgpdxlcd = pphColDescr->Pdrgpdxlcd(); pdrgpdxlcd->AddRef(); m_pdxltabdesc->SetColumnDescriptors(pdrgpdxlcd); // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerTableDescr::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerTableDescr::StartElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const, // xmlszQname const Attributes& attrs ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenTableDescr), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // parse table name from attributes m_pdxltabdesc = CDXLOperatorFactory::Pdxltabdesc(m_pphm->Pmm(), attrs); // install column descriptor parsers CParseHandlerBase *pphColDescr = CParseHandlerFactory::Pph(m_pmp, CDXLTokens::XmlstrToken(EdxltokenColumns), m_pphm, this); m_pphm->ActivateParseHandler(pphColDescr); // store parse handler this->Append(pphColDescr); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerSortColList::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerSortColList::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarSortColList), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE ( gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz() ); } const ULONG ulLen = this->UlLength(); // add sorting columns from child parse handlers for (ULONG ul = 0; ul < ulLen; ul++) { CParseHandlerSortCol *pphSortCol = dynamic_cast<CParseHandlerSortCol *>((*this)[ul]); AddChildFromParseHandler(pphSortCol); } #ifdef GPOS_DEBUG m_pdxln->Pdxlop()->AssertValid(m_pdxln, false /* fValidateChildren */); #endif // GPOS_DEBUG // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerFilter::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerFilter::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarFilter), xmlszLocalname) && 0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarJoinFilter), xmlszLocalname) && 0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarOneTimeFilter), xmlszLocalname) && 0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarRecheckCondFilter), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } if (0 < this->UlLength()) { // filter node was not empty CParseHandlerScalarOp *pphOp = dynamic_cast<CParseHandlerScalarOp *>((*this)[0]); AddChildFromParseHandler(pphOp); } // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerDefaultValueExpr::EndElement // // @doc: // Processes a Xerces end element event // //--------------------------------------------------------------------------- void CParseHandlerDefaultValueExpr::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenColumnDefaultValue), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } if (0 < this->UlLength()) { GPOS_ASSERT(1 == this->UlLength()); // get node for default value expression from child parse handler CParseHandlerScalarOp *pphChild = dynamic_cast<CParseHandlerScalarOp *>((*this)[0]); m_pdxln = pphChild->Pdxln(); m_pdxln->AddRef(); } // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerColDescr::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerColDescr::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if (0 == XMLString::compareString(xmlszLocalname, CDXLTokens::XmlstrToken(EdxltokenColumns))) { // finish the columns block GPOS_ASSERT(NULL != m_pdrgdxlcd); m_pphm->DeactivateHandler(); } else if (0 == XMLString::compareString(xmlszLocalname, CDXLTokens::XmlstrToken(EdxltokenColumn))) { // finish up a column descriptor GPOS_ASSERT(NULL != m_pdxlcd); GPOS_ASSERT(NULL != m_pdrgdxlcd); m_pdrgdxlcd->Append(m_pdxlcd); // reset column descr m_pdxlcd = NULL; } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerProjElem::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerProjElem::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarProjElem), xmlszLocalname)) { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } // construct node from the parsed expression node m_pdxln = GPOS_NEW(m_pmp) CDXLNode(m_pmp, m_pdxlop); CParseHandlerScalarOp *pph = dynamic_cast<CParseHandlerScalarOp*>((*this)[0]); // store constructed child AddChildFromParseHandler(pph); // deactivate handler m_pphm->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarWindowFrameEdge::EndElement // // @doc: // Processes a Xerces end element event // //--------------------------------------------------------------------------- void CParseHandlerScalarWindowFrameEdge::EndElement ( const XMLCh* const, // xmlszUri, const XMLCh* const xmlszLocalname, const XMLCh* const // xmlszQname ) { if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarWindowFrameLeadingEdge), xmlszLocalname) || 0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarWindowFrameTrailingEdge), xmlszLocalname) ) { const ULONG ulSize = this->UlLength(); if (0 < ulSize) { GPOS_ASSERT(1 == ulSize); // limit count node was not empty CParseHandlerScalarOp *pphChild = dynamic_cast<CParseHandlerScalarOp *>((*this)[0]); AddChildFromParseHandler(pphChild); } // deactivate handler m_pphm->DeactivateHandler(); } else { CWStringDynamic *pstr = CDXLUtils::PstrFromXMLCh(m_pphm->Pmm(), xmlszLocalname); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, pstr->Wsz()); } }