//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarCast::StartElement // // @doc: // Processes a Xerces start element event // //--------------------------------------------------------------------------- void CParseHandlerScalarCast::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(EdxltokenScalarCast), element_local_name)) { if (NULL != m_dxl_node) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } // parse and create scalar cast CDXLScalarCast *dxl_op = (CDXLScalarCast*) CDXLOperatorFactory::MakeDXLCast(m_parse_handler_mgr->GetDXLMemoryManager(), attrs); m_dxl_node = GPOS_NEW(m_mp) CDXLNode(m_mp, dxl_op); // parse handler for child scalar node CParseHandlerBase *child_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenScalar), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(child_parse_handler); // store 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: // CParseHandlerQueryOutput::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerQueryOutput::EndElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const // element_qname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenQueryOutput), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } const ULONG size = this->Length(); for (ULONG ul = 0; ul < size; ul++) { CParseHandlerScalarIdent *child_parse_handler = dynamic_cast<CParseHandlerScalarIdent *>((*this)[ul]); GPOS_ASSERT(NULL != child_parse_handler); CDXLNode *pdxlnIdent = child_parse_handler->CreateDXLNode(); pdxlnIdent->AddRef(); m_dxl_array->Append(pdxlnIdent); } // deactivate handler m_parse_handler_mgr->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerLogicalCTEProducer::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerLogicalCTEProducer::EndElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const // element_qname ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenLogicalCTEProducer), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } GPOS_ASSERT(NULL != m_dxl_node ); CParseHandlerLogicalOp *child_parse_handler = dynamic_cast<CParseHandlerLogicalOp*>((*this)[0]); AddChildFromParseHandler(child_parse_handler); #ifdef GPOS_DEBUG m_dxl_node->GetOperator()->AssertValid(m_dxl_node, false /* validate_children */); #endif // GPOS_DEBUG m_parse_handler_mgr->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerWindowKeyList::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerWindowKeyList::EndElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const // element_qname ) { if ( 0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenWindowKeyList), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } GPOS_ASSERT(NULL != m_dxl_window_key_array); const ULONG size = this->Length(); // add the window keys to the list for (ULONG idx = 0; idx < size; idx++) { CParseHandlerWindowKey *window_key_parse_handler = dynamic_cast<CParseHandlerWindowKey *>((*this)[idx]); m_dxl_window_key_array->Append(window_key_parse_handler->GetDxlWindowKeyGen()); } // deactivate handler m_parse_handler_mgr->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerLogicalDelete::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerLogicalDelete::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(EdxltokenLogicalDelete), 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, EdxltokenLogicalDelete); m_segid_colid = CDXLOperatorFactory::ExtractConvertAttrValueToUlong(m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenGpSegmentIdColId, EdxltokenLogicalDelete); const XMLCh *deletion_colids = CDXLOperatorFactory::ExtractAttrValue(attrs, EdxltokenDeleteCols, EdxltokenLogicalDelete); m_deletion_colid_array = CDXLOperatorFactory::ExtractIntsToUlongArray(m_parse_handler_mgr->GetDXLMemoryManager(), deletion_colids, EdxltokenDeleteCols, EdxltokenLogicalDelete); // 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: // CParseHandlerHashExpr::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerHashExpr::EndElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const // element_qname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarHashExpr), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } CParseHandlerScalarOp *op_parse_handler = dynamic_cast<CParseHandlerScalarOp *>((*this)[0]); GPOS_ASSERT(NULL != op_parse_handler->CreateDXLNode()); // construct node from the parsed expression node m_dxl_node = GPOS_NEW(m_mp) CDXLNode(m_mp, m_dxl_op); AddChildFromParseHandler(op_parse_handler); // deactivate handler m_parse_handler_mgr->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerMDGPDBFunc::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerMDGPDBFunc::EndElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const // element_qname ) { if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenGPDBFunc), element_local_name)) { // construct the MD func object from its part GPOS_ASSERT(m_mdid->IsValid() && NULL != m_mdname); m_imd_obj = GPOS_NEW(m_mp) CMDFunctionGPDB(m_mp, m_mdid, m_mdname, m_mdid_type_result, m_mdid_types_array, m_returns_set, m_func_stability, m_func_data_access, m_is_strict); // deactivate handler m_parse_handler_mgr->DeactivateHandler(); } else if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenGPDBFuncResultTypeId), element_local_name) && 0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenOutputCols), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerHashExpr::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerHashExpr::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(EdxltokenScalarHashExpr), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } // parse and create hash expr operator m_dxl_op = (CDXLScalarHashExpr *) CDXLOperatorFactory::MakeDXLHashExpr(m_parse_handler_mgr->GetDXLMemoryManager(), attrs); // create and activate the parse handler for the child scalar expression node CParseHandlerBase *op_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenScalar), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(op_parse_handler); // store child parse handler this->Append(op_parse_handler); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarCoalesce::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerScalarCoalesce::EndElement ( const XMLCh* const ,// element_uri const XMLCh* const element_local_name, const XMLCh* const // element_qname ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarCoalesce), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } // construct node m_dxl_node = GPOS_NEW(m_mp) CDXLNode(m_mp, GPOS_NEW(m_mp) CDXLScalarCoalesce(m_mp, m_mdid_type)); // loop over children and add them to this parsehandler const ULONG size = this->Length(); for (ULONG idx = 0; idx < size; idx++) { CParseHandlerScalarOp *child_parse_handler = dynamic_cast<CParseHandlerScalarOp *>((*this)[idx]); AddChildFromParseHandler(child_parse_handler); } // deactivate handler m_parse_handler_mgr->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerStatsDerivedRelation::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerStatsDerivedRelation::EndElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const // element_qname ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenStatsDerivedRelation), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } // must have at least one column stats GPOS_ASSERT(0 < this->Length()); // array of derived column statistics CDXLStatsDerivedColumnArray *dxl_stats_derived_col_array = GPOS_NEW(m_mp) CDXLStatsDerivedColumnArray(m_mp); const ULONG num_of_drvd_col_stats = this->Length(); for (ULONG idx = 0; idx < num_of_drvd_col_stats; idx++) { CParseHandlerStatsDerivedColumn *stats_derived_col_parse_handler = dynamic_cast<CParseHandlerStatsDerivedColumn*>( (*this)[idx]); CDXLStatsDerivedColumn *pdxlstatdercol = stats_derived_col_parse_handler->GetDxlStatsDerivedCol(); pdxlstatdercol->AddRef(); dxl_stats_derived_col_array->Append(pdxlstatdercol); } m_dxl_stats_derived_relation = GPOS_NEW(m_mp) CDXLStatsDerivedRelation(m_rows, m_empty, dxl_stats_derived_col_array); // deactivate handler m_parse_handler_mgr->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarSubquery::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerScalarSubquery::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(EdxltokenScalarSubquery), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } // parse column id ULONG colid = CDXLOperatorFactory::ExtractConvertAttrValueToUlong ( m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenColId, EdxltokenScalarSubquery ); m_dxl_op = GPOS_NEW(m_mp) CDXLScalarSubquery(m_mp, colid); // parse handler for child node CParseHandlerBase *child_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenLogical), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(child_parse_handler); // store child parse handler in array this->Append(child_parse_handler); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerWindowKeyList::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerWindowKeyList::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(EdxltokenWindowKeyList), element_local_name)) { m_dxl_window_key_array = GPOS_NEW(m_mp) CDXLWindowKeyArray(m_mp); } else if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenWindowKey), element_local_name)) { // we must have seen a window key list already GPOS_ASSERT(NULL != m_dxl_window_key_array); // start new window key element CParseHandlerBase *window_key_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenWindowKey), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(window_key_parse_handler); // store parse handler this->Append(window_key_parse_handler); window_key_parse_handler->startElement(element_uri, element_local_name, element_qname, attrs); } else { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } }
// invoked by Xerces to process an opening tag void CParseHandlerMDIndexInfoList::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(EdxltokenIndexInfoList), element_local_name)) { m_mdindex_info_array = GPOS_NEW(m_mp) CMDIndexInfoArray(m_mp); } else if (0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenIndexInfo), element_local_name)) { // parse mdid IMDId *mdid = CDXLOperatorFactory::ExtractConvertAttrValueToMdId(m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenMdid, EdxltokenIndexInfo); // parse index partial info BOOL is_partial = CDXLOperatorFactory::ExtractConvertAttrValueToBool(m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenIndexPartial, EdxltokenIndexInfo); CMDIndexInfo *md_index_info = GPOS_NEW(m_mp) CMDIndexInfo ( mdid, is_partial ); m_mdindex_info_array->Append(md_index_info); } else { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarSubquery::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerScalarSubquery::EndElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const // element_qname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarSubquery), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } // construct node from parsed components GPOS_ASSERT(1 == this->Length()); GPOS_ASSERT(NULL != m_dxl_op); CParseHandlerLogicalOp *child_parse_handler = dynamic_cast<CParseHandlerLogicalOp *>((*this)[0]); m_dxl_node = GPOS_NEW(m_mp) CDXLNode(m_mp, m_dxl_op); // add constructed child AddChildFromParseHandler(child_parse_handler); #ifdef GPOS_DEBUG m_dxl_op->AssertValid(m_dxl_node, false /* validate_children */); #endif // GPOS_DEBUG // deactivate handler m_parse_handler_mgr->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @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: // CParseHandlerTableScan::StartElement // // @doc: // Start element helper function // //--------------------------------------------------------------------------- void CParseHandlerTableScan::StartElement ( const XMLCh* const element_local_name, Edxltoken token_type ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(token_type), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } if (EdxltokenPhysicalTableScan == token_type) { m_dxl_op = GPOS_NEW(m_mp) CDXLPhysicalTableScan(m_mp); } else { GPOS_ASSERT(EdxltokenPhysicalExternalScan == token_type); m_dxl_op = GPOS_NEW(m_mp) CDXLPhysicalExternalScan(m_mp); } // create child node parsers in reverse order of their expected occurrence // parse handler for 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); // parse handler for the filter CParseHandlerBase *filter_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenScalarFilter), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(filter_parse_handler); // parse handler for the proj list CParseHandlerBase *proj_list_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenScalarProjList), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(proj_list_parse_handler); //parse handler for the properties of the operator CParseHandlerBase *prop_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenProperties), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(prop_parse_handler); // store child parse handlers in array this->Append(prop_parse_handler); this->Append(proj_list_parse_handler); this->Append(filter_parse_handler); this->Append(table_descr_parse_handler); }
//--------------------------------------------------------------------------- // @function: // CColumnFactory::PcrCreate // // @doc: // Variant without name for computed columns // //--------------------------------------------------------------------------- CColRef * CColumnFactory::PcrCreate ( const IMDType *pmdtype, INT type_modifier ) { // increment atomic counter ULONG id = m_aul.Incr(); WCHAR wszFmt[] = GPOS_WSZ_LIT("ColRef_%04d"); CWStringDynamic *pstrTempName = GPOS_NEW(m_mp) CWStringDynamic(m_mp); CAutoP<CWStringDynamic> a_pstrTempName(pstrTempName); pstrTempName->AppendFormat(wszFmt, id); CWStringConst strName(pstrTempName->GetBuffer()); return PcrCreate(pmdtype, type_modifier, id, CName(&strName)); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerPhysicalWindow::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerPhysicalWindow::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(EdxltokenPhysicalWindow), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } const XMLCh *xml_str_part_by_cols = CDXLOperatorFactory::ExtractAttrValue(attrs, EdxltokenPartKeys, EdxltokenPhysicalWindow); m_part_by_colid_array = CDXLOperatorFactory::ExtractIntsToUlongArray(m_parse_handler_mgr->GetDXLMemoryManager(), xml_str_part_by_cols, EdxltokenPartKeys, EdxltokenPhysicalWindow); GPOS_ASSERT(NULL != m_part_by_colid_array); // parse handler for window key list CParseHandlerBase *window_key_list_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenWindowKeyList), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(window_key_list_parse_handler); // parse handler for child node CParseHandlerBase *child_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenPhysical), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(child_parse_handler); // parse handler for the filter CParseHandlerBase *filter_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenScalarFilter), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(filter_parse_handler); // parse handler for the proj list CParseHandlerBase *proj_list_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenScalarProjList), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(proj_list_parse_handler); //parse handler for the properties of the operator CParseHandlerBase *prop_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenProperties), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(prop_parse_handler); // store child parse handlers in array this->Append(prop_parse_handler); this->Append(proj_list_parse_handler); this->Append(filter_parse_handler); this->Append(child_parse_handler); this->Append(window_key_list_parse_handler); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerIndexDescr::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerIndexDescr::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(EdxltokenIndexDescr), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } // generate the index descriptor m_dxl_index_descr = CDXLOperatorFactory::MakeDXLIndexDescr(m_parse_handler_mgr->GetDXLMemoryManager(), attrs); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarIdent::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerScalarIdent::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(EdxltokenScalarIdent), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } // parse and create identifier operator m_dxl_op = (CDXLScalarIdent *) CDXLOperatorFactory::MakeDXLScalarIdent(m_parse_handler_mgr->GetDXLMemoryManager(), attrs); }
// Invoked by Xerces to process a closing tag void CParseHandlerScalarPartListNullTest::EndElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const // element_qname ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarPartListNullTest), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } GPOS_ASSERT(NULL != m_dxl_node); // deactivate handler m_parse_handler_mgr->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerIndexDescr::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerIndexDescr::EndElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const // element_qname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenIndexDescr), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } GPOS_ASSERT(0 == this->Length()); // deactivate handler m_parse_handler_mgr->DeactivateHandler(); }
// Invoked by Xerces to process an opening tag void CParseHandlerScalarPartListNullTest::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(EdxltokenScalarPartListNullTest), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } ULONG partition_level = CDXLOperatorFactory::ExtractConvertAttrValueToUlong(m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenPartLevel, EdxltokenScalarPartListNullTest); BOOL is_null = CDXLOperatorFactory::ExtractConvertAttrValueToBool(m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenScalarIsNull, EdxltokenScalarPartListNullTest); m_dxl_node = GPOS_NEW(m_mp) CDXLNode (m_mp, GPOS_NEW(m_mp) CDXLScalarPartListNullTest(m_mp, partition_level, is_null)); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerTableScan::EndElement // // @doc: // End element helper function // //--------------------------------------------------------------------------- void CParseHandlerTableScan::EndElement ( const XMLCh* const element_local_name, Edxltoken token_type ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(token_type), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } // construct node from the created child nodes CParseHandlerProperties *prop_parse_handler = dynamic_cast<CParseHandlerProperties *>((*this)[0]); CParseHandlerProjList *proj_list_parse_handler = dynamic_cast<CParseHandlerProjList*>((*this)[1]); CParseHandlerFilter *filter_parse_handler = dynamic_cast<CParseHandlerFilter *>((*this)[2]); CParseHandlerTableDescr *table_descr_parse_handler = dynamic_cast<CParseHandlerTableDescr*>((*this)[3]); GPOS_ASSERT(NULL != table_descr_parse_handler->GetDXLTableDescr()); // set table descriptor CDXLTableDescr *table_descr = table_descr_parse_handler->GetDXLTableDescr(); table_descr->AddRef(); m_dxl_op->SetTableDescriptor(table_descr); m_dxl_node = GPOS_NEW(m_mp) CDXLNode(m_mp, m_dxl_op); // set statictics and physical properties CParseHandlerUtils::SetProperties(m_dxl_node, prop_parse_handler); // add constructed children AddChildFromParseHandler(proj_list_parse_handler); AddChildFromParseHandler(filter_parse_handler); #ifdef GPOS_DEBUG m_dxl_op->AssertValid(m_dxl_node, false /* validate_children */); #endif // GPOS_DEBUG // deactivate handler m_parse_handler_mgr->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerLogicalDelete::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerLogicalDelete::EndElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const // element_qname ) { if (0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenLogicalDelete), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } GPOS_ASSERT(2 == this->Length()); CParseHandlerTableDescr *table_descr_parse_handler = dynamic_cast<CParseHandlerTableDescr*>((*this)[0]); CParseHandlerLogicalOp *logical_op_parse_handler = dynamic_cast<CParseHandlerLogicalOp*>((*this)[1]); GPOS_ASSERT(NULL != table_descr_parse_handler->GetDXLTableDescr()); GPOS_ASSERT(NULL != logical_op_parse_handler->CreateDXLNode()); CDXLTableDescr *table_descr = table_descr_parse_handler->GetDXLTableDescr(); table_descr->AddRef(); m_dxl_node = GPOS_NEW(m_mp) CDXLNode ( m_mp, GPOS_NEW(m_mp) CDXLLogicalDelete(m_mp, table_descr, m_ctid_colid, m_segid_colid, m_deletion_colid_array) ); AddChildFromParseHandler(logical_op_parse_handler); #ifdef GPOS_DEBUG m_dxl_node->GetOperator()->AssertValid(m_dxl_node, false /* validate_children */); #endif // GPOS_DEBUG // deactivate handler m_parse_handler_mgr->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarArrayCoerceExpr::EndElement // // @doc: // Processes a Xerces end element event // //--------------------------------------------------------------------------- void CParseHandlerScalarArrayCoerceExpr::EndElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const // element_qname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarArrayCoerceExpr), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } GPOS_ASSERT(1 == this->Length()); // add constructed child from child parse handlers CParseHandlerScalarOp *child_parse_handler = dynamic_cast<CParseHandlerScalarOp*>((*this)[0]); AddChildFromParseHandler(child_parse_handler); // deactivate handler m_parse_handler_mgr->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerStatisticsConfig::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerStatisticsConfig::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(EdxltokenStatisticsConfig), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } // parse statistics configuration options CDouble damping_factor_filter = CDXLOperatorFactory::ExtractConvertAttrValueToDouble(m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenDampingFactorFilter, EdxltokenStatisticsConfig); CDouble damping_factor_join = CDXLOperatorFactory::ExtractConvertAttrValueToDouble(m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenDampingFactorJoin, EdxltokenStatisticsConfig); CDouble damping_factor_groupby = CDXLOperatorFactory::ExtractConvertAttrValueToDouble(m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenDampingFactorGroupBy, EdxltokenStatisticsConfig); m_stats_conf = GPOS_NEW(m_mp) CStatisticsConfig(m_mp, damping_factor_filter, damping_factor_join, damping_factor_groupby); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerScalarIdent::EndElement // // @doc: // Invoked by Xerces to process a closing tag // //--------------------------------------------------------------------------- void CParseHandlerScalarIdent::EndElement ( const XMLCh* const, // element_uri, const XMLCh* const element_local_name, const XMLCh* const // element_qname ) { if(0 != XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarIdent), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } // construct scalar ident node GPOS_ASSERT(NULL != m_dxl_op); m_dxl_node = GPOS_NEW(m_mp) CDXLNode(m_mp); m_dxl_node->SetOperator(m_dxl_op); // deactivate handler m_parse_handler_mgr->DeactivateHandler(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerQueryOutput::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerQueryOutput::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(EdxltokenQueryOutput), element_local_name)) { // start the query output section in the DXL document GPOS_ASSERT(NULL == m_dxl_array); m_dxl_array = GPOS_NEW(m_mp) CDXLNodeArray(m_mp); } else if(0 == XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenScalarIdent), element_local_name)) { // we must have seen a proj list already and initialized the proj list node GPOS_ASSERT(NULL != m_dxl_array); // start new scalar ident element CParseHandlerBase *child_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenScalarIdent), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(child_parse_handler); // store parse handler this->Append(child_parse_handler); child_parse_handler->startElement(element_uri, element_local_name, element_qname, attrs); } else { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerLogicalCTEProducer::StartElement // // @doc: // Invoked by Xerces to process an opening tag // //--------------------------------------------------------------------------- void CParseHandlerLogicalCTEProducer::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(EdxltokenLogicalCTEProducer), element_local_name)) { CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name); GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag, str->GetBuffer()); } // parse cteid and create cte operator ULONG id = CDXLOperatorFactory::ExtractConvertAttrValueToUlong ( m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenCTEId, EdxltokenLogicalCTEProducer ); ULongPtrArray *output_colids_array = CDXLOperatorFactory::ExtractConvertValuesToArray(m_parse_handler_mgr->GetDXLMemoryManager(), attrs, EdxltokenColumns, EdxltokenLogicalCTEProducer); m_dxl_node = GPOS_NEW(m_mp) CDXLNode(m_mp, GPOS_NEW(m_mp) CDXLLogicalCTEProducer(m_mp, id, output_colids_array)); // create and activate the parse handler for the child expression node CParseHandlerBase *child_parse_handler = CParseHandlerFactory::GetParseHandler(m_mp, CDXLTokens::XmlstrToken(EdxltokenLogical), m_parse_handler_mgr, this); m_parse_handler_mgr->ActivateParseHandler(child_parse_handler); // store parse handler this->Append(child_parse_handler); }