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