//--------------------------------------------------------------------------- // @function: // CCNFConverterTest::EresUnittest_Basic // // @doc: // Basic test // //--------------------------------------------------------------------------- GPOS_RESULT CCNFConverterTest::EresUnittest_Basic() { CAutoMemoryPool amp; IMemoryPool *pmp = amp.Pmp(); // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(pmp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp); typedef CExpression *(*Pfpexpr)(IMemoryPool*); Pfpexpr rgpf[] = { CTestUtils::PexprLogicalSelectWithNestedAnd, CTestUtils::PexprLogicalSelectWithNestedOr, CTestUtils::PexprLogicalSelectWithEvenNestedNot, CTestUtils::PexprLogicalSelectWithOddNestedNot, CTestUtils::PexprLogicalSelectWithNestedAndOrNot }; for (ULONG i = 0; i < GPOS_ARRAY_SIZE(rgpf); i++) { // install opt context in TLS CAutoOptCtxt aoc ( pmp, &mda, NULL, /* pceeval */ CTestUtils::Pcm(pmp) ); // generate expression CExpression *pexpr = rgpf[i](pmp); CExpression *pexprPreprocessed = CExpressionPreprocessor::PexprPreprocess(pmp, pexpr); CWStringDynamic str(pmp); COstreamString oss(&str); oss << std::endl << "SCALAR EXPR:" << std::endl << *(*pexpr)[1] << std::endl; GPOS_TRACE(str.Wsz()); str.Reset(); if (1 < pexprPreprocessed->UlArity()) { CExpression *pexprCNF = CCNFConverter::Pexpr2CNF(pmp, (*pexprPreprocessed)[1]); oss << std::endl << "CNF REPRESENTATION:" << std::endl << *pexprCNF << std::endl; GPOS_TRACE(str.Wsz()); str.Reset(); pexprCNF->Release(); } pexpr->Release(); pexprPreprocessed->Release(); } return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CParseHandlerTest::EresParseAndSerializePlan // // @doc: // Verifies that after parsing the given DXL file into a DXL tree, // it will be serialized back to the same string. // //--------------------------------------------------------------------------- GPOS_RESULT CParseHandlerTest::EresParseAndSerializePlan ( 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; const CHAR *szValidationPath = NULL; if (fValidate) { szValidationPath = CTestUtils::m_szXSDPath; } // the root of the parsed DXL tree ULLONG ullPlanId = ULLONG_MAX; ULLONG ullPlanSpaceSize = ULLONG_MAX; CDXLNode *pdxlnRoot = CDXLUtils::PdxlnParsePlan(pmp, szDXL, szValidationPath, &ullPlanId, &ullPlanSpaceSize); GPOS_CHECK_ABORT; oss << "Serializing parsed tree" << std::endl; CWStringDynamic strPlan(pmp); COstreamString osPlan(&strPlan); CDXLUtils::SerializePlan(pmp, osPlan, pdxlnRoot, ullPlanId, ullPlanSpaceSize, true /*fSerializeHeaderFooter*/, true /*fIndent*/); GPOS_CHECK_ABORT; CWStringDynamic dstrExpected(pmp); dstrExpected.AppendFormat(GPOS_WSZ_LIT("%s"), szDXL); if (!dstrExpected.FEquals(&strPlan)) { GPOS_TRACE(dstrExpected.Wsz()); GPOS_TRACE(strPlan.Wsz()); GPOS_ASSERT(!"Not matching"); } // cleanup pdxlnRoot->Release(); GPOS_DELETE_ARRAY(szDXL); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CParseHandlerTest::EresParseAndSerializePlan // // @doc: // Verifies that after parsing the given DXL file into a DXL tree, // it will be serialized back to the same string. // //--------------------------------------------------------------------------- GPOS_RESULT CParseHandlerTest::EresParseAndSerializePlan ( IMemoryPool *mp, const CHAR *dxl_filename, BOOL fValidate ) { CWStringDynamic str(mp); COstreamString oss(&str); // read DXL file CHAR *dxl_string = CDXLUtils::Read(mp, dxl_filename); GPOS_CHECK_ABORT; const CHAR *szValidationPath = NULL; if (fValidate) { szValidationPath = CTestUtils::m_szXSDPath; } // the root of the parsed DXL tree ULLONG plan_id = gpos::ullong_max; ULLONG plan_space_size = gpos::ullong_max; CDXLNode *root_dxl_node = CDXLUtils::GetPlanDXLNode(mp, dxl_string, szValidationPath, &plan_id, &plan_space_size); GPOS_CHECK_ABORT; oss << "Serializing parsed tree" << std::endl; CWStringDynamic strPlan(mp); COstreamString osPlan(&strPlan); CDXLUtils::SerializePlan(mp, osPlan, root_dxl_node, plan_id, plan_space_size, true /*serialize_header_footer*/, true /*indentation*/); GPOS_CHECK_ABORT; CWStringDynamic dstrExpected(mp); dstrExpected.AppendFormat(GPOS_WSZ_LIT("%s"), dxl_string); if (!dstrExpected.Equals(&strPlan)) { GPOS_TRACE(dstrExpected.GetBuffer()); GPOS_TRACE(strPlan.GetBuffer()); GPOS_ASSERT(!"Not matching"); } // cleanup root_dxl_node->Release(); GPOS_DELETE_ARRAY(dxl_string); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CParseHandlerTest::EresParseAndSerializeScalarExpr // // @doc: // Parses a ScalarExpr and verifies that the serialization is identical // to the original input. // //--------------------------------------------------------------------------- GPOS_RESULT CParseHandlerTest::EresParseAndSerializeScalarExpr ( IMemoryPool *mp, const CHAR *dxl_filename, BOOL fValidate ) { // read DXL file CHAR *dxl_string = CDXLUtils::Read(mp, dxl_filename); GPOS_CHECK_ABORT; const CHAR *szValidationPath = NULL; if (fValidate) { szValidationPath = CTestUtils::m_szXSDPath; } // the root of the parsed DXL tree CDXLNode *root_dxl_node = CDXLUtils::ParseDXLToScalarExprDXLNode(mp, dxl_string, szValidationPath); GPOS_CHECK_ABORT; CWStringDynamic str(mp); COstreamString oss(&str); oss << "Serializing parsed tree" << std::endl; CWStringDynamic *scalar_expr_str = CDXLUtils::SerializeScalarExpr(mp, root_dxl_node, true /*serialize_header_footer*/, true /*indentation*/); GPOS_CHECK_ABORT; CWStringDynamic dstrExpected(mp); dstrExpected.AppendFormat(GPOS_WSZ_LIT("%s"), dxl_string); GPOS_RESULT eres = GPOS_OK; if (!dstrExpected.Equals(scalar_expr_str)) { GPOS_TRACE(dstrExpected.GetBuffer()); GPOS_TRACE(scalar_expr_str->GetBuffer()); GPOS_ASSERT(!"Not matching"); eres = GPOS_FAILED; } // cleanup root_dxl_node->Release(); GPOS_DELETE(scalar_expr_str); GPOS_DELETE_ARRAY(dxl_string); return eres; }
//--------------------------------------------------------------------------- // @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: // CTreeMapTest::EresUnittest_Unrank // // @doc: // Rehydrate all trees encoded in the map // //--------------------------------------------------------------------------- GPOS_RESULT CTreeMapTest::EresUnittest_Unrank() { CAutoMemoryPool amp; IMemoryPool *pmp = amp.Pmp(); TestMap *ptmap = PtmapLoad(pmp); // debug print CWStringDynamic str(pmp); COstreamString oss(&str); ULLONG ullCount = ptmap->UllCount(); for (ULONG ulRank = 0; ulRank < ullCount; ulRank++) { oss << "=== tree rank: " << ulRank << " ===" << std::endl; BOOL fFlag = true; CNode *pnd = ptmap->PrUnrank(pmp, &fFlag, ulRank); (void) pnd->OsPrint(oss); pnd->Release(); } GPOS_TRACE(str.Wsz()); GPOS_DELETE(ptmap); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CTreeMapTest::EresUnittest_Count // // @doc: // Count and debug output of all counts at various nodes // //--------------------------------------------------------------------------- GPOS_RESULT CTreeMapTest::EresUnittest_Count() { CAutoMemoryPool amp; IMemoryPool *pmp = amp.Pmp(); TestMap *ptmap = PtmapLoad(pmp); // debug print CWStringDynamic str(pmp); COstreamString oss(&str); ULLONG ullCount = ptmap->UllCount(); oss << "total number of trees: " << ullCount << std::endl; #ifdef GPOS_DEBUG for (ULONG ul = 0; ul < ulElems; ul++) { oss << "node: " << ul << " count: " << ptmap->UllCount(&rgul[ul]) << std::endl; } (void) ptmap->OsPrint(oss); #endif // GPOS_DEBUG GPOS_TRACE(str.Wsz()); GPOS_DELETE(ptmap); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CMDAccessorTest::EresUnittest_Navigate // // @doc: // Test fetching a MD object from the cache and navigating its dependent // objects // //--------------------------------------------------------------------------- GPOS_RESULT CMDAccessorTest::EresUnittest_Navigate() { CAutoMemoryPool amp; IMemoryPool *mp = amp.Pmp(); // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(mp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp); // lookup a function in the MD cache CMDIdGPDB *mdid_func = GPOS_NEW(mp) CMDIdGPDB(GPDB_FUNC_TIMEOFDAY /* OID */, 1 /* major version */, 0 /* minor version */); const IMDFunction *pmdfunc = mda.RetrieveFunc(mdid_func); // lookup function return type IMDId *pmdidFuncReturnType = pmdfunc->GetResultTypeMdid(); const IMDType *pimdtype = mda.RetrieveType(pmdidFuncReturnType); // lookup equality operator for function return type IMDId *pmdidEqOp = pimdtype->GetMdidForCmpType(IMDType::EcmptEq); #ifdef GPOS_DEBUG const IMDScalarOp *md_scalar_op = #endif mda.RetrieveScOp(pmdidEqOp); #ifdef GPOS_DEBUG // print objects CWStringDynamic str(mp); COstreamString oss(&str); oss << std::endl; oss << std::endl; pmdfunc->DebugPrint(oss); oss << std::endl; pimdtype->DebugPrint(oss); oss << std::endl; md_scalar_op->DebugPrint(oss); oss << std::endl; GPOS_TRACE(str.GetBuffer()); #endif mdid_func->Release(); return GPOS_OK; }
//--------------------------------------------------------------------------- // @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 *mp, const CHAR *dxl_filename, BOOL fValidate ) { CWStringDynamic str(mp); COstreamString oss(&str); // read DXL file CHAR *dxl_string = CDXLUtils::Read(mp, dxl_filename); GPOS_CHECK_ABORT; // parse the metadata objects into a dynamic array const CHAR *szValidationPath = NULL; if (fValidate) { szValidationPath = CTestUtils::m_szXSDPath; } IMDCacheObjectArray *mdcache_obj_array = CDXLUtils::ParseDXLToIMDObjectArray(mp, dxl_string, szValidationPath); GPOS_ASSERT(NULL != mdcache_obj_array); GPOS_CHECK_ABORT; oss << "Serializing metadata objects" << std::endl; CWStringDynamic *metadata_str = CDXLUtils::SerializeMetadata(mp, mdcache_obj_array, true /*serialize_header_footer*/, true /*indentation*/); GPOS_CHECK_ABORT; CWStringDynamic dstrExpected(mp); dstrExpected.AppendFormat(GPOS_WSZ_LIT("%s"), dxl_string); if (!dstrExpected.Equals(metadata_str)) { GPOS_TRACE(metadata_str->GetBuffer()); GPOS_ASSERT(false); } mdcache_obj_array->Release(); GPOS_DELETE(metadata_str); GPOS_DELETE_ARRAY(dxl_string); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CParseHandlerTest::EresParseAndSerializeQuery // // @doc: // Verifies that after parsing the given DXL file into a DXL tree // representing a query, it will be serialized back to the same string. // //--------------------------------------------------------------------------- GPOS_RESULT CParseHandlerTest::EresParseAndSerializeQuery ( IMemoryPool *pmp, const CHAR *szDXLFileName, BOOL fValidate ) { CWStringDynamic str(pmp); COstreamString oss(&str); // read DXL file CHAR *szDXL = CDXLUtils::SzRead(pmp, szDXLFileName); const CHAR *szValidationPath = NULL; if (fValidate) { szValidationPath = CTestUtils::m_szXSDPath; } // the root of the parsed DXL tree CQueryToDXLResult *pq2dxlresult = CDXLUtils::PdxlnParseDXLQuery(pmp, szDXL, szValidationPath); GPOS_ASSERT(NULL != pq2dxlresult); oss << "Serializing parsed tree" << std::endl; CDXLNode *pdxlnRoot = const_cast<CDXLNode *>(pq2dxlresult->Pdxln()); DrgPdxln* pdrgpdxln = const_cast<DrgPdxln* >(pq2dxlresult->PdrgpdxlnOutputCols()); DrgPdxln* pdrgpdxlnCTE = const_cast<DrgPdxln* >(pq2dxlresult->PdrgpdxlnCTE()); CWStringDynamic wstrQuery(pmp); COstreamString osQuery(&wstrQuery); CDXLUtils::SerializeQuery(pmp, osQuery, pdxlnRoot, pdrgpdxln, pdrgpdxlnCTE, true /*fSerializeHeaderFooter*/, true /*fIndent*/); CWStringDynamic dstrExpected(pmp); dstrExpected.AppendFormat(GPOS_WSZ_LIT("%s"), szDXL); if (!dstrExpected.FEquals(&wstrQuery)) { GPOS_TRACE(wstrQuery.Wsz()); } // cleanup GPOS_DELETE(pq2dxlresult); GPOS_DELETE_ARRAY(szDXL); return GPOS_OK; }
//--------------------------------------------------------------------------- // @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: // CParseHandlerTest::EresParseAndSerializeQuery // // @doc: // Verifies that after parsing the given DXL file into a DXL tree // representing a query, it will be serialized back to the same string. // //--------------------------------------------------------------------------- GPOS_RESULT CParseHandlerTest::EresParseAndSerializeQuery ( IMemoryPool *mp, const CHAR *dxl_filename, BOOL fValidate ) { CWStringDynamic str(mp); COstreamString oss(&str); // read DXL file CHAR *dxl_string = CDXLUtils::Read(mp, dxl_filename); const CHAR *szValidationPath = NULL; if (fValidate) { szValidationPath = CTestUtils::m_szXSDPath; } // the root of the parsed DXL tree CQueryToDXLResult *pq2dxlresult = CDXLUtils::ParseQueryToQueryDXLTree(mp, dxl_string, szValidationPath); GPOS_ASSERT(NULL != pq2dxlresult); oss << "Serializing parsed tree" << std::endl; CDXLNode *root_dxlnode = const_cast<CDXLNode *>(pq2dxlresult->CreateDXLNode()); CDXLNodeArray* dxl_array = const_cast<CDXLNodeArray* >(pq2dxlresult->GetOutputColumnsDXLArray()); CDXLNodeArray* cte_producers = const_cast<CDXLNodeArray* >(pq2dxlresult->GetCTEProducerDXLArray()); CWStringDynamic wstrQuery(mp); COstreamString osQuery(&wstrQuery); CDXLUtils::SerializeQuery(mp, osQuery, root_dxlnode, dxl_array, cte_producers, true /*serialize_header_footer*/, true /*indentation*/); CWStringDynamic dstrExpected(mp); dstrExpected.AppendFormat(GPOS_WSZ_LIT("%s"), dxl_string); if (!dstrExpected.Equals(&wstrQuery)) { GPOS_TRACE(wstrQuery.GetBuffer()); } // cleanup GPOS_DELETE(pq2dxlresult); GPOS_DELETE_ARRAY(dxl_string); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CTableDescriptorTest::EresUnittest_Basic // // @doc: // basic naming, assignment thru copy constructors // //--------------------------------------------------------------------------- GPOS_RESULT CTableDescriptorTest::EresUnittest_Basic() { CAutoMemoryPool amp; IMemoryPool *pmp = amp.Pmp(); // Setup an MD cache with a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(pmp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp); // install opt context in TLS CAutoOptCtxt aoc ( pmp, &mda, NULL, /* pceeval */ CTestUtils::Pcm(pmp) ); CWStringConst strName(GPOS_WSZ_LIT("MyTable")); CMDIdGPDB *pmdid = GPOS_NEW(pmp) CMDIdGPDB(GPOPT_MDCACHE_TEST_OID, 1, 1); CTableDescriptor *ptabdesc = CTestUtils::PtabdescCreate(pmp, 10, pmdid, CName(&strName)); #ifdef GPOS_DEBUG CWStringDynamic str(pmp); COstreamString oss(&str); ptabdesc->OsPrint(oss); GPOS_TRACE(str.Wsz()); #endif // GPOS_DEBUG ptabdesc->Release(); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CMDAccessorTest::EresUnittest_Datum // // @doc: // Test type factory method for creating base type datums // //--------------------------------------------------------------------------- GPOS_RESULT CMDAccessorTest::EresUnittest_Datum() { CAutoMemoryPool amp; IMemoryPool *mp = amp.Pmp(); // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(mp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp); // install opt context in TLS CAutoOptCtxt aoc ( mp, &mda, NULL, /* pceeval */ CTestUtils::GetCostModel(mp) ); // create an INT4 datum const IMDTypeInt4 *pmdtypeint4 = mda.PtMDType<IMDTypeInt4>(CTestUtils::m_sysidDefault); IDatumInt4 *pdatumInt4 = pmdtypeint4->CreateInt4Datum(mp, 5, false /* is_null */); GPOS_ASSERT(5 == pdatumInt4->Value()); // create a BOOL datum const IMDTypeBool *pmdtypebool = mda.PtMDType<IMDTypeBool>(CTestUtils::m_sysidDefault); IDatumBool *pdatumBool = pmdtypebool->CreateBoolDatum(mp, false, false /* is_null */); GPOS_ASSERT(false == pdatumBool->GetValue()); // create an OID datum const IMDTypeOid *pmdtypeoid = mda.PtMDType<IMDTypeOid>(CTestUtils::m_sysidDefault); IDatumOid *pdatumOid = pmdtypeoid->CreateOidDatum(mp, 20, false /* is_null */); GPOS_ASSERT(20 == pdatumOid->OidValue()); #ifdef GPOS_DEBUG // for debug traces CWStringDynamic str(mp); COstreamString oss(&str); // print objects oss << std::endl; oss << "Int4 datum" << std::endl; pdatumInt4->OsPrint(oss); oss << std::endl; oss << "Bool datum" << std::endl; pdatumBool->OsPrint(oss); oss << std::endl; oss << "Oid datum" << std::endl; pdatumOid->OsPrint(oss); GPOS_TRACE(str.GetBuffer()); #endif // cleanup pdatumInt4->Release(); pdatumBool->Release(); pdatumOid->Release(); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CMiniDumperDXLTest::EresUnittest_Basic // // @doc: // Test minidumps in case of an exception // //--------------------------------------------------------------------------- GPOS_RESULT CMiniDumperDXLTest::EresUnittest_Basic() { CAutoMemoryPool amp(CAutoMemoryPool::ElcNone); IMemoryPool *mp = amp.Pmp(); CWStringDynamic minidumpstr(mp); COstreamString oss(&minidumpstr); CMiniDumperDXL mdrs(mp); mdrs.Init(&oss); CHAR file_name[GPOS_FILE_NAME_BUF_SIZE]; GPOS_TRY { CSerializableStackTrace serStackTrace; // read the dxl document CHAR *szQueryDXL = CDXLUtils::Read(mp, szQueryFile); // parse the DXL query tree from the given DXL document CQueryToDXLResult *ptroutput = CDXLUtils::ParseQueryToQueryDXLTree(mp, szQueryDXL, NULL); GPOS_CHECK_ABORT; CSerializableQuery serQuery(mp, ptroutput->CreateDXLNode(), ptroutput->GetOutputColumnsDXLArray(), ptroutput->GetCTEProducerDXLArray()); // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); // we need to use an auto pointer for the cache here to ensure // deleting memory of cached objects when we throw CAutoP<CMDAccessor::MDCache> apcache; apcache = CCacheFactory::CreateCache<gpopt::IMDCacheObject*, gpopt::CMDKey*> ( true, // fUnique 0 /* unlimited cache quota */, CMDKey::UlHashMDKey, CMDKey::FEqualMDKey ); CMDAccessor::MDCache *pcache = apcache.Value(); CMDAccessor mda(mp, pcache, CTestUtils::m_sysidDefault, pmdp); CSerializableMDAccessor serMDA(&mda); CAutoTraceFlag atfPrintQuery(EopttracePrintQuery, true); CAutoTraceFlag atfPrintPlan(EopttracePrintPlan, true); CAutoTraceFlag atfTest(EtraceTest, true); COptimizerConfig *optimizer_config = GPOS_NEW(mp) COptimizerConfig ( CEnumeratorConfig::GetEnumeratorCfg(mp, 0 /*plan_id*/), CStatisticsConfig::PstatsconfDefault(mp), CCTEConfig::PcteconfDefault(mp), ICostModel::PcmDefault(mp), CHint::PhintDefault(mp), CWindowOids::GetWindowOids(mp) ); // setup opt ctx CAutoOptCtxt aoc ( mp, &mda, NULL, /* pceeval */ CTestUtils::GetCostModel(mp) ); // translate DXL Tree -> Expr Tree CTranslatorDXLToExpr *pdxltr = GPOS_NEW(mp) CTranslatorDXLToExpr(mp, &mda); CExpression *pexprTranslated = pdxltr->PexprTranslateQuery ( ptroutput->CreateDXLNode(), ptroutput->GetOutputColumnsDXLArray(), ptroutput->GetCTEProducerDXLArray() ); gpdxl::ULongPtrArray *pdrgul = pdxltr->PdrgpulOutputColRefs(); gpmd::CMDNameArray *pdrgpmdname = pdxltr->Pdrgpmdname(); ULONG ulSegments = GPOPT_TEST_SEGMENTS; CQueryContext *pqc = CQueryContext::PqcGenerate(mp, pexprTranslated, pdrgul, pdrgpmdname, true /*fDeriveStats*/); // optimize logical expression tree into physical expression tree. CEngine eng(mp); CSerializableOptimizerConfig serOptConfig(mp, optimizer_config); eng.Init(pqc, NULL /*search_stage_array*/); eng.Optimize(); CExpression *pexprPlan = eng.PexprExtractPlan(); (void) pexprPlan->PrppCompute(mp, pqc->Prpp()); // translate plan into DXL IntPtrArray *pdrgpiSegments = GPOS_NEW(mp) IntPtrArray(mp); GPOS_ASSERT(0 < ulSegments); for (ULONG ul = 0; ul < ulSegments; ul++) { pdrgpiSegments->Append(GPOS_NEW(mp) INT(ul)); } CTranslatorExprToDXL ptrexprtodxl(mp, &mda, pdrgpiSegments); CDXLNode *pdxlnPlan = ptrexprtodxl.PdxlnTranslate(pexprPlan, pqc->PdrgPcr(), pqc->Pdrgpmdname()); GPOS_ASSERT(NULL != pdxlnPlan); CSerializablePlan serPlan(mp, pdxlnPlan, optimizer_config->GetEnumeratorCfg()->GetPlanId(), optimizer_config->GetEnumeratorCfg()->GetPlanSpaceSize()); GPOS_CHECK_ABORT; // simulate an exception GPOS_OOM_CHECK(NULL); } GPOS_CATCH_EX(ex) { // unless we're simulating faults, the exception must be OOM GPOS_ASSERT_IMP ( !GPOS_FTRACE(EtraceSimulateAbort) && !GPOS_FTRACE(EtraceSimulateIOError) && !IWorker::m_enforce_time_slices, CException::ExmaSystem == ex.Major() && CException::ExmiOOM == ex.Minor() ); mdrs.Finalize(); GPOS_RESET_EX; CWStringDynamic str(mp); COstreamString oss(&str); oss << std::endl << "Minidump" << std::endl; oss << minidumpstr.GetBuffer(); oss << std::endl; // dump the same to a temp file ULONG ulSessionId = 1; ULONG ulCommandId = 1; CMinidumperUtils::GenerateMinidumpFileName(file_name, GPOS_FILE_NAME_BUF_SIZE, ulSessionId, ulCommandId, NULL /*szMinidumpFileName*/); std::wofstream osMinidump(file_name); osMinidump << minidumpstr.GetBuffer(); oss << "Minidump file: " << file_name << std::endl; GPOS_TRACE(str.GetBuffer()); } GPOS_CATCH_END; // TODO: - Feb 11, 2013; enable after fixing problems with serializing // XML special characters (OPT-2996) // // try to load minidump file // CDXLMinidump *pdxlmd = CMinidumperUtils::PdxlmdLoad(mp, file_name); // GPOS_ASSERT(NULL != pdxlmd); // delete pdxlmd; // delete temp file ioutils::Unlink(file_name); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CSubqueryHandlerTest::EresUnittest_Subquery2Apply // // @doc: // Test of subquery handler // //--------------------------------------------------------------------------- GPOS_RESULT CSubqueryHandlerTest::EresUnittest_Subquery2Apply() { CAutoMemoryPool amp; IMemoryPool *mp = amp.Pmp(); // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(mp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp); typedef CExpression *(*Pfpexpr)(IMemoryPool*, BOOL); Pfpexpr rgpf[] = { CSubqueryTestUtils::PexprSelectWithAggSubquery, CSubqueryTestUtils::PexprSelectWithAggSubqueryConstComparison, CSubqueryTestUtils::PexprProjectWithAggSubquery, CSubqueryTestUtils::PexprSelectWithAnySubquery, CSubqueryTestUtils::PexprProjectWithAnySubquery, CSubqueryTestUtils::PexprSelectWithAllSubquery, CSubqueryTestUtils::PexprProjectWithAllSubquery, CSubqueryTestUtils::PexprSelectWithExistsSubquery, CSubqueryTestUtils::PexprProjectWithExistsSubquery, CSubqueryTestUtils::PexprSelectWithNotExistsSubquery, CSubqueryTestUtils::PexprProjectWithNotExistsSubquery, CSubqueryTestUtils::PexprSelectWithNestedCmpSubquery, CSubqueryTestUtils::PexprSelectWithCmpSubqueries, CSubqueryTestUtils::PexprSelectWithSubqueryConjuncts, CSubqueryTestUtils::PexprProjectWithSubqueries, CSubqueryTestUtils::PexprSelectWith2LevelsCorrSubquery, CSubqueryTestUtils::PexprJoinWithAggSubquery, CSubqueryTestUtils::PexprSelectWithAggSubqueryOverJoin, CSubqueryTestUtils::PexprSelectWithNestedSubquery, CSubqueryTestUtils::PexprSubqueriesInNullTestContext, CSubqueryTestUtils::PexprSubqueriesInDifferentContexts, CSubqueryTestUtils::PexprSelectWithSubqueryDisjuncts, CSubqueryTestUtils::PexprSelectWithNestedAnySubqueries, CSubqueryTestUtils::PexprSelectWithNestedAllSubqueries, CSubqueryTestUtils::PexprUndecorrelatableAnySubquery, CSubqueryTestUtils::PexprUndecorrelatableAllSubquery, CSubqueryTestUtils::PexprUndecorrelatableExistsSubquery, CSubqueryTestUtils::PexprUndecorrelatableNotExistsSubquery, CSubqueryTestUtils::PexprUndecorrelatableScalarSubquery, }; // xforms to test CXformSet *xform_set = GPOS_NEW(mp) CXformSet(mp); (void) xform_set->ExchangeSet(CXform::ExfSubqJoin2Apply); (void) xform_set->ExchangeSet(CXform::ExfSelect2Apply); (void) xform_set->ExchangeSet(CXform::ExfProject2Apply); BOOL fCorrelated = true; // we generate two expressions using each generator const ULONG size = 2 * GPOS_ARRAY_SIZE(rgpf); for (ULONG ul = 0; ul < size; ul++) { ULONG ulIndex = ul / 2; // install opt context in TLS CAutoOptCtxt aoc ( mp, &mda, NULL, /* pceeval */ CTestUtils::GetCostModel(mp) ); // generate expression CExpression *pexpr = rgpf[ulIndex](mp, fCorrelated); // check for subq xforms CXformSet *pxfsCand = CLogical::PopConvert(pexpr->Pop())->PxfsCandidates(mp); pxfsCand->Intersection(xform_set); CXformSetIter xsi(*pxfsCand); while (xsi.Advance()) { CXform *pxform = CXformFactory::Pxff()->Pxf(xsi.TBit()); GPOS_ASSERT(NULL != pxform); CWStringDynamic str(mp); COstreamString oss(&str); oss << std::endl << "INPUT:" << std::endl << *pexpr << std::endl; CXformContext *pxfctxt = GPOS_NEW(mp) CXformContext(mp); CXformResult *pxfres = GPOS_NEW(mp) CXformResult(mp); // calling the xform to perform subquery to Apply transformation pxform->Transform(pxfctxt, pxfres, pexpr); CExpression *pexprResult = pxfres->PexprNext(); oss << std::endl << "OUTPUT:" << std::endl; if (NULL != pexprResult) { oss << *pexprResult << std::endl; } else { oss << "\tNo subquery unnesting output" << std::endl; } GPOS_TRACE(str.GetBuffer()); str.Reset(); pxfres->Release(); pxfctxt->Release(); } pxfsCand->Release(); pexpr->Release(); fCorrelated = !fCorrelated; } xform_set->Release(); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CSubqueryHandlerTest::EresUnittest_SubqueryWithDisjunction // // @doc: // Test case of subqueries in a disjunctive tree // //--------------------------------------------------------------------------- GPOS_RESULT CSubqueryHandlerTest::EresUnittest_SubqueryWithDisjunction() { // use own memory pool CAutoMemoryPool amp(CAutoMemoryPool::ElcNone); IMemoryPool *mp = amp.Pmp(); // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(mp, CMDCache::Pcache()); mda.RegisterProvider(CTestUtils::m_sysidDefault, pmdp); // install opt context in TLS CAutoOptCtxt aoc ( mp, &mda, NULL, /* pceeval */ CTestUtils::GetCostModel(mp) ); // create a subquery with const table get expression CExpression *pexprOuter = NULL; CExpression *pexprInner = NULL; CSubqueryTestUtils::GenerateGetExpressions(mp, &pexprOuter, &pexprInner); CExpression *pexpr = CSubqueryTestUtils::PexprSelectWithSubqueryBoolOp(mp, pexprOuter, pexprInner, true /*fCorrelated*/, CScalarBoolOp::EboolopOr); CXform *pxform = CXformFactory::Pxff()->Pxf(CXform::ExfSelect2Apply); CWStringDynamic str(mp); COstreamString oss(&str); oss << std::endl << "EXPRESSION:" << std::endl << *pexpr << std::endl; CExpression *pexprLogical = (*pexpr)[0]; CExpression *pexprScalar = (*pexpr)[1]; oss << std::endl << "LOGICAL:" << std::endl << *pexprLogical << std::endl; oss << std::endl << "SCALAR:" << std::endl << *pexprScalar << std::endl; GPOS_TRACE(str.GetBuffer()); str.Reset(); CXformContext *pxfctxt = GPOS_NEW(mp) CXformContext(mp); CXformResult *pxfres = GPOS_NEW(mp) CXformResult(mp); // calling the xform to perform subquery to Apply transformation pxform->Transform(pxfctxt, pxfres, pexpr); CExpression *pexprResult = pxfres->PexprNext(); oss << std::endl << "NEW LOGICAL:" << std::endl << *((*pexprResult)[0]) << std::endl; oss << std::endl << "RESIDUAL SCALAR:" << std::endl << *((*pexprResult)[1]) << std::endl; GPOS_TRACE(str.GetBuffer()); str.Reset(); pxfres->Release(); pxfctxt->Release(); pexpr->Release(); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CSubqueryHandlerTest::EresUnittest_SubqueryWithConstSubqueries // // @doc: // Test of subquery handler for ALL subquery over const table get // //--------------------------------------------------------------------------- GPOS_RESULT CSubqueryHandlerTest::EresUnittest_SubqueryWithConstSubqueries() { CAutoMemoryPool amp; IMemoryPool *mp = amp.Pmp(); // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); // we need to use an auto pointer for the cache here to ensure // deleting memory of cached objects when we throw CAutoP<CMDAccessor::MDCache> apcache; apcache = CCacheFactory::CreateCache<gpopt::IMDCacheObject*, gpopt::CMDKey*> ( true, // fUnique 0 /* unlimited cache quota */, CMDKey::UlHashMDKey, CMDKey::FEqualMDKey ); CMDAccessor::MDCache *pcache = apcache.Value(); { CMDAccessor mda(mp, pcache, CTestUtils::m_sysidDefault, pmdp); // install opt context in TLS CAutoOptCtxt aoc ( mp, &mda, NULL, /* pceeval */ CTestUtils::GetCostModel(mp) ); // create a subquery with const table get expression CExpression *pexpr = CSubqueryTestUtils::PexprSubqueryWithDisjunction(mp); CXform *pxform = CXformFactory::Pxff()->Pxf(CXform::ExfSelect2Apply); CWStringDynamic str(mp); COstreamString oss(&str); oss << std::endl << "EXPRESSION:" << std::endl << *pexpr << std::endl; CExpression *pexprLogical = (*pexpr)[0]; CExpression *pexprScalar = (*pexpr)[1]; oss << std::endl << "LOGICAL:" << std::endl << *pexprLogical << std::endl; oss << std::endl << "SCALAR:" << std::endl << *pexprScalar << std::endl; GPOS_TRACE(str.GetBuffer()); str.Reset(); CXformContext *pxfctxt = GPOS_NEW(mp) CXformContext(mp); CXformResult *pxfres = GPOS_NEW(mp) CXformResult(mp); // calling the xform to perform subquery to Apply transformation; // xform must fail since we do not expect constant subqueries pxform->Transform(pxfctxt, pxfres, pexpr); CExpression *pexprResult = pxfres->PexprNext(); oss << std::endl << "NEW LOGICAL:" << std::endl << *((*pexprResult)[0]) << std::endl; oss << std::endl << "RESIDUAL SCALAR:" << std::endl << *((*pexprResult)[1]) << std::endl; GPOS_TRACE(str.GetBuffer()); str.Reset(); pxfres->Release(); pxfctxt->Release(); pexpr->Release(); } return GPOS_FAILED; }
//--------------------------------------------------------------------------- // @function: // CContradictionTest::EresUnittest_Constraint // // @doc: // Tests for constraint property derivation and constraint push down // //--------------------------------------------------------------------------- GPOS_RESULT CContradictionTest::EresUnittest_Constraint() { CAutoMemoryPool amp; IMemoryPool *pmp = amp.Pmp(); // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(pmp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp); typedef CExpression *(*Pfpexpr)(IMemoryPool*); Pfpexpr rgpf[] = { CTestUtils::PexprLogicalApplyWithOuterRef<CLogicalInnerApply>, CTestUtils::PexprLogicalApply<CLogicalLeftSemiApply>, CTestUtils::PexprLogicalApply<CLogicalLeftAntiSemiApply>, CTestUtils::PexprLogicalApplyWithOuterRef<CLogicalLeftOuterApply>, CTestUtils::PexprLogicalGet, CTestUtils::PexprLogicalGetPartitioned, CTestUtils::PexprLogicalSelect, CTestUtils::PexprLogicalSelectCmpToConst, CTestUtils::PexprLogicalSelectPartitioned, CTestUtils::PexprLogicalSelectWithContradiction, CTestUtils::PexprLogicalJoin<CLogicalInnerJoin>, CTestUtils::PexprLogicalJoin<CLogicalLeftOuterJoin>, CTestUtils::PexprLogicalJoin<CLogicalLeftSemiJoin>, CTestUtils::PexprLogicalJoin<CLogicalLeftAntiSemiJoin>, CTestUtils::PexprLogicalGbAgg, CTestUtils::PexprLogicalGbAggOverJoin, CTestUtils::PexprLogicalGbAggWithSum, CTestUtils::PexprLogicalLimit, CTestUtils::PexprLogicalNAryJoin, CTestUtils::PexprLogicalProject, CTestUtils::PexprConstTableGet5, CTestUtils::PexprLogicalDynamicGet, CTestUtils::PexprLogicalSequence, CTestUtils::PexprLogicalTVFTwoArgs, }; for (ULONG i = 0; i < GPOS_ARRAY_SIZE(rgpf); i++) { // install opt context in TLS CAutoOptCtxt aoc ( pmp, &mda, NULL, /* pceeval */ CTestUtils::Pcm(pmp) ); // generate simple expression CExpression *pexpr = rgpf[i](pmp); // self-match GPOS_ASSERT(pexpr->FMatchDebug(pexpr)); // debug print CWStringDynamic str(pmp, GPOS_WSZ_LIT("\n")); COstreamString oss(&str); oss << "EXPR:" << std::endl << *pexpr << std::endl; GPOS_TRACE(str.Wsz()); str.Reset(); #ifdef GPOS_DEBUG // derive properties on expression (void) pexpr->PdpDerive(); oss << std::endl << "DERIVED PROPS:" << std::endl; GPOS_TRACE(str.Wsz()); str.Reset(); pexpr->DbgPrint(); #endif // GPOS_DEBUG CExpression *pexprPreprocessed = CExpressionPreprocessor::PexprPreprocess(pmp, pexpr); oss << std::endl << "PREPROCESSED EXPR:" << std::endl << *pexprPreprocessed << std::endl; GPOS_TRACE(str.Wsz()); str.Reset(); // cleanup pexprPreprocessed->Release(); pexpr->Release(); } return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CXformTest::EresUnittest_ApplyXforms_CTE // // @doc: // Test application of CTE-related xforms // //--------------------------------------------------------------------------- GPOS_RESULT CXformTest::EresUnittest_ApplyXforms_CTE() { CAutoMemoryPool amp; IMemoryPool *pmp = amp.Pmp(); // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(pmp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp); // install opt context in TLS CAutoOptCtxt aoc ( pmp, &mda, NULL, /* pceeval */ CTestUtils::Pcm(pmp) ); DrgPexpr *pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp); // create producer ULONG ulCTEId = 0; CExpression *pexprProducer = CTestUtils::PexprLogicalCTEProducerOverSelect(pmp, ulCTEId); COptCtxt::PoctxtFromTLS()->Pcteinfo()->AddCTEProducer(pexprProducer); pdrgpexpr->Append(pexprProducer); DrgPcr *pdrgpcrProducer = CLogicalCTEProducer::PopConvert(pexprProducer->Pop())->Pdrgpcr(); DrgPcr *pdrgpcrConsumer = CUtils::PdrgpcrCopy(pmp, pdrgpcrProducer); CExpression *pexprConsumer = GPOS_NEW(pmp) CExpression ( pmp, GPOS_NEW(pmp) CLogicalCTEConsumer(pmp, ulCTEId, pdrgpcrConsumer) ); pdrgpexpr->Append(pexprConsumer); COptCtxt::PoctxtFromTLS()->Pcteinfo()->IncrementConsumers(ulCTEId); pexprConsumer->AddRef(); CExpression *pexprSelect = CTestUtils::PexprLogicalSelect(pmp, pexprConsumer); pdrgpexpr->Append(pexprSelect); pexprSelect->AddRef(); CExpression *pexprAnchor = GPOS_NEW(pmp) CExpression ( pmp, GPOS_NEW(pmp) CLogicalCTEAnchor(pmp, ulCTEId), pexprSelect ); pdrgpexpr->Append(pexprAnchor); const ULONG ulLen = pdrgpexpr->UlLength(); for (ULONG ul = 0; ul < ulLen; ul++) { CWStringDynamic str(pmp); COstreamString oss(&str); ApplyExprXforms(pmp, oss, (*pdrgpexpr)[ul]); GPOS_TRACE(str.Wsz()); } pdrgpexpr->Release(); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CXformTest::EresUnittest_ApplyXforms // // @doc: // Test application of different xforms // //--------------------------------------------------------------------------- GPOS_RESULT CXformTest::EresUnittest_ApplyXforms() { CAutoMemoryPool amp; IMemoryPool *pmp = amp.Pmp(); typedef CExpression *(*Pfpexpr)(IMemoryPool*); Pfpexpr rgpf[] = { CTestUtils::PexprLogicalApplyWithOuterRef<CLogicalInnerApply>, CTestUtils::PexprLogicalApply<CLogicalLeftSemiApply>, CTestUtils::PexprLogicalApply<CLogicalLeftAntiSemiApply>, CTestUtils::PexprLogicalApply<CLogicalLeftAntiSemiApplyNotIn>, CTestUtils::PexprLogicalApplyWithOuterRef<CLogicalLeftOuterApply>, CTestUtils::PexprLogicalGet, CTestUtils::PexprLogicalExternalGet, CTestUtils::PexprLogicalSelect, CTestUtils::PexprLogicalLimit, CTestUtils::PexprLogicalJoin<CLogicalInnerJoin>, CTestUtils::PexprLogicalJoin<CLogicalLeftOuterJoin>, CTestUtils::PexprLogicalJoin<CLogicalLeftSemiJoin>, CTestUtils::PexprLogicalJoin<CLogicalLeftAntiSemiJoin>, CTestUtils::PexprLogicalJoin<CLogicalLeftAntiSemiJoinNotIn>, CTestUtils::PexprLogicalGbAgg, CTestUtils::PexprLogicalGbAggOverJoin, CTestUtils::PexprLogicalGbAggWithSum, CTestUtils::PexprLogicalGbAggDedupOverInnerJoin, CTestUtils::PexprLogicalNAryJoin, CTestUtils::PexprLeftOuterJoinOnNAryJoin, CTestUtils::PexprLogicalProject, CTestUtils::PexprLogicalSequence, CTestUtils::PexprLogicalGetPartitioned, CTestUtils::PexprLogicalSelectPartitioned, CTestUtils::PexprLogicalDynamicGet, CTestUtils::PexprJoinPartitionedInner<CLogicalInnerJoin>, CTestUtils::PexprLogicalSelectCmpToConst, CTestUtils::PexprLogicalTVFTwoArgs, CTestUtils::PexprLogicalTVFNoArgs, CTestUtils::PexprLogicalInsert, CTestUtils::PexprLogicalDelete, CTestUtils::PexprLogicalUpdate, CTestUtils::PexprLogicalAssert, CTestUtils::PexprLogicalJoin<CLogicalFullOuterJoin>, PexprJoinTree, CTestUtils::PexprLogicalJoinWithPartitionedAndIndexedInnerChild, }; // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(pmp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp); // install opt context in TLS CAutoOptCtxt aoc ( pmp, &mda, NULL, /* pceeval */ CTestUtils::Pcm(pmp) ); for (ULONG ul = 0; ul < GPOS_ARRAY_SIZE(rgpf); ul++) { CWStringDynamic str(pmp); COstreamString oss(&str); // generate simple expression CExpression *pexpr = rgpf[ul](pmp); ApplyExprXforms(pmp, oss, pexpr); GPOS_TRACE(str.Wsz()); pexpr->Release(); } return GPOS_OK; }