//--------------------------------------------------------------------------- // @function: // CJoinOrderTest::EresUnittest_Expand // // @doc: // Simple expansion test // //--------------------------------------------------------------------------- GPOS_RESULT CJoinOrderTest::EresUnittest_Expand() { 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) ); // build test case CExpression *pexpr = CTestUtils::PexprLogicalNAryJoin(pmp); DrgPexpr *pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp); ULONG ulArity = pexpr->UlArity(); for (ULONG ul = 0; ul < ulArity - 1; ul++) { CExpression *pexprChild = (*pexpr)[ul]; pexprChild->AddRef(); pdrgpexpr->Append(pexprChild); } DrgPexpr *pdrgpexprConj = CPredicateUtils::PdrgpexprConjuncts(pmp, (*pexpr)[ulArity - 1]); // add predicates selectively to trigger special case of cross join DrgPexpr *pdrgpexprTest = GPOS_NEW(pmp) DrgPexpr(pmp); for (ULONG ul = 0; ul < pdrgpexprConj->UlLength() - 1; ul++) { CExpression *pexprConjunct = (*pdrgpexprConj)[ul]; pexprConjunct->AddRef(); pdrgpexprTest->Append(pexprConjunct); } pdrgpexprConj->Release(); // single-table predicate CColRefSet *pcrsOutput = CDrvdPropRelational::Pdprel((*pdrgpexpr)[ulArity - 2]->PdpDerive())->PcrsOutput(); CExpression *pexprSingleton = CUtils::PexprScalarEqCmp(pmp, pcrsOutput->PcrAny(), pcrsOutput->PcrAny()); pdrgpexprTest->Append(pexprSingleton); CJoinOrder jo(pmp, pdrgpexpr, pdrgpexprTest); CExpression *pexprResult = jo.PexprExpand(); { CAutoTrace at(pmp); at.Os() << std::endl << "INPUT:" << std::endl << *pexpr << std::endl; at.Os() << std::endl << "OUTPUT:" << std::endl << *pexprResult << std::endl; } CRefCount::SafeRelease(pexprResult); pexpr->Release(); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CJoinOrderTest::EresUnittest_ExpandMinCard // // @doc: // Expansion expansion based on cardinality of intermediate results // //--------------------------------------------------------------------------- GPOS_RESULT CJoinOrderTest::EresUnittest_ExpandMinCard() { CAutoMemoryPool amp; IMemoryPool *pmp = amp.Pmp(); // array of relation names CWStringConst rgscRel[] = { GPOS_WSZ_LIT("Rel10"), GPOS_WSZ_LIT("Rel3"), GPOS_WSZ_LIT("Rel4"), GPOS_WSZ_LIT("Rel6"), GPOS_WSZ_LIT("Rel7"), GPOS_WSZ_LIT("Rel8"), GPOS_WSZ_LIT("Rel12"), GPOS_WSZ_LIT("Rel13"), GPOS_WSZ_LIT("Rel5"), GPOS_WSZ_LIT("Rel14"), GPOS_WSZ_LIT("Rel15"), GPOS_WSZ_LIT("Rel1"), GPOS_WSZ_LIT("Rel11"), GPOS_WSZ_LIT("Rel2"), GPOS_WSZ_LIT("Rel9"), }; // array of relation IDs ULONG rgulRel[] = { GPOPT_TEST_REL_OID10, GPOPT_TEST_REL_OID3, GPOPT_TEST_REL_OID4, GPOPT_TEST_REL_OID6, GPOPT_TEST_REL_OID7, GPOPT_TEST_REL_OID8, GPOPT_TEST_REL_OID12, GPOPT_TEST_REL_OID13, GPOPT_TEST_REL_OID5, GPOPT_TEST_REL_OID14, GPOPT_TEST_REL_OID15, GPOPT_TEST_REL_OID1, GPOPT_TEST_REL_OID11, GPOPT_TEST_REL_OID2, GPOPT_TEST_REL_OID9, }; const ULONG ulRels = GPOS_ARRAY_SIZE(rgscRel); GPOS_ASSERT(GPOS_ARRAY_SIZE(rgulRel) == ulRels); // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(pmp, CMDCache::Pcache()); mda.RegisterProvider(CTestUtils::m_sysidDefault, pmdp); { // install opt context in TLS CAutoOptCtxt aoc ( pmp, &mda, NULL, /* pceeval */ CTestUtils::Pcm(pmp) ); CExpression *pexprNAryJoin = CTestUtils::PexprLogicalNAryJoin(pmp, rgscRel, rgulRel, ulRels, false /*fCrossProduct*/); // derive stats on input expression CExpressionHandle exprhdl(pmp); exprhdl.Attach(pexprNAryJoin); exprhdl.DeriveStats(pmp, pmp, NULL /*prprel*/, NULL /*pdrgpstatCtxt*/); DrgPexpr *pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp); for (ULONG ul = 0; ul < ulRels; ul++) { CExpression *pexprChild = (*pexprNAryJoin)[ul]; pexprChild->AddRef(); pdrgpexpr->Append(pexprChild); } DrgPexpr *pdrgpexprPred = CPredicateUtils::PdrgpexprConjuncts(pmp, (*pexprNAryJoin)[ulRels]); pdrgpexpr->AddRef(); pdrgpexprPred->AddRef(); CJoinOrderMinCard jomc(pmp, pdrgpexpr, pdrgpexprPred); CExpression *pexprResult = jomc.PexprExpand(); { CAutoTrace at(pmp); at.Os() << std::endl << "INPUT:" << std::endl << *pexprNAryJoin << std::endl; at.Os() << std::endl << "OUTPUT:" << std::endl << *pexprResult << std::endl; } pexprResult->Release(); pexprNAryJoin->Release(); pdrgpexpr->Release(); pdrgpexprPred->Release(); } return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CPredicateUtilsTest::EresUnittest_Conjunctions // // @doc: // Test extraction and construction of conjuncts // //--------------------------------------------------------------------------- GPOS_RESULT CPredicateUtilsTest::EresUnittest_Conjunctions() { 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) ); // build conjunction DrgPexpr *pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp); const ULONG ulConjs = 3; for (ULONG ul = 0; ul < ulConjs; ul++) { pdrgpexpr->Append(CUtils::PexprScalarConstBool(pmp, true /*fValue*/)); } CExpression *pexprConjunction = CUtils::PexprScalarBoolOp(pmp, CScalarBoolOp::EboolopAnd, pdrgpexpr); // break into conjuncts DrgPexpr *pdrgpexprExtract = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprConjunction); GPOS_ASSERT(pdrgpexprExtract->UlLength() == ulConjs); // collapse into single conjunct CExpression *pexpr = CPredicateUtils::PexprConjunction(pmp, pdrgpexprExtract); GPOS_ASSERT(NULL != pexpr); GPOS_ASSERT(CUtils::FScalarConstTrue(pexpr)); pexpr->Release(); // collapse empty input array to conjunct CExpression *pexprSingleton = CPredicateUtils::PexprConjunction(pmp, NULL /*pdrgpexpr*/); GPOS_ASSERT(NULL != pexprSingleton); pexprSingleton->Release(); pexprConjunction->Release(); // conjunction on scalar comparisons CExpression *pexprGet = CTestUtils::PexprLogicalGet(pmp); CColRefSet *pcrs = CDrvdPropRelational::Pdprel(pexprGet->PdpDerive())->PcrsOutput(); CColRef *pcr1 = pcrs->PcrAny(); CColRef *pcr2 = pcrs->PcrFirst(); CExpression *pexprCmp1 = CUtils::PexprScalarCmp(pmp, pcr1, pcr2, IMDType::EcmptEq); CExpression *pexprCmp2 = CUtils::PexprScalarCmp(pmp, pcr1, CUtils::PexprScalarConstInt4(pmp, 1 /*iVal*/), IMDType::EcmptEq); CExpression *pexprConj = CPredicateUtils::PexprConjunction(pmp, pexprCmp1, pexprCmp2); pdrgpexprExtract = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprConj); GPOS_ASSERT(2 == pdrgpexprExtract->UlLength()); pdrgpexprExtract->Release(); pexprCmp1->Release(); pexprCmp2->Release(); pexprConj->Release(); pexprGet->Release(); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CPredicateUtilsTest::EresUnittest_PlainEqualities // // @doc: // Test the extraction of equality predicates between scalar identifiers // //--------------------------------------------------------------------------- GPOS_RESULT CPredicateUtilsTest::EresUnittest_PlainEqualities() { 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) ); CExpression *pexprLeft = CTestUtils::PexprLogicalGet(pmp); CExpression *pexprRight = CTestUtils::PexprLogicalGet(pmp); DrgPexpr *pdrgpexprOriginal = GPOS_NEW(pmp) DrgPexpr(pmp); CColRefSet *pcrsLeft = CDrvdPropRelational::Pdprel(pexprLeft->PdpDerive())->PcrsOutput(); CColRefSet *pcrsRight = CDrvdPropRelational::Pdprel(pexprRight->PdpDerive())->PcrsOutput(); CColRef *pcrLeft = pcrsLeft->PcrAny(); CColRef *pcrRight = pcrsRight->PcrAny(); // generate an equality predicate between two column reference CExpression *pexprScIdentEquality = CUtils::PexprScalarEqCmp(pmp, pcrLeft, pcrRight); pexprScIdentEquality->AddRef(); pdrgpexprOriginal->Append(pexprScIdentEquality); // generate a non-equality predicate between two column reference CExpression *pexprScIdentInequality = CUtils::PexprScalarCmp(pmp, pcrLeft, pcrRight, CWStringConst(GPOS_WSZ_LIT("<")), GPOS_NEW(pmp) CMDIdGPDB(GPDB_INT4_LT_OP)); pexprScIdentInequality->AddRef(); pdrgpexprOriginal->Append(pexprScIdentInequality); // generate an equality predicate between a column reference and a constant value CExpression *pexprScalarConstInt4 = CUtils::PexprScalarConstInt4(pmp, 10 /*fValue*/); CExpression *pexprScIdentConstEquality = CUtils::PexprScalarEqCmp(pmp, pexprScalarConstInt4, pcrRight); pdrgpexprOriginal->Append(pexprScIdentConstEquality); GPOS_ASSERT(3 == pdrgpexprOriginal->UlLength()); DrgPexpr *pdrgpexprResult = CPredicateUtils::PdrgpexprPlainEqualities(pmp, pdrgpexprOriginal); GPOS_ASSERT(1 == pdrgpexprResult->UlLength()); // clean up pdrgpexprOriginal->Release(); pdrgpexprResult->Release(); pexprLeft->Release(); pexprRight->Release(); pexprScIdentEquality->Release(); pexprScIdentInequality->Release(); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CPredicateUtilsTest::EresUnittest_Disjunctions // // @doc: // Test extraction and construction of disjuncts // //--------------------------------------------------------------------------- GPOS_RESULT CPredicateUtilsTest::EresUnittest_Disjunctions() { 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) ); // build disjunction DrgPexpr *pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp); const ULONG ulDisjs = 3; for (ULONG ul = 0; ul < ulDisjs; ul++) { pdrgpexpr->Append(CUtils::PexprScalarConstBool(pmp, false /*fValue*/)); } CExpression *pexprDisjunction = CUtils::PexprScalarBoolOp(pmp, CScalarBoolOp::EboolopOr, pdrgpexpr); // break into disjuncts DrgPexpr *pdrgpexprExtract = CPredicateUtils::PdrgpexprDisjuncts(pmp, pexprDisjunction); GPOS_ASSERT(pdrgpexprExtract->UlLength() == ulDisjs); // collapse into single disjunct CExpression *pexpr = CPredicateUtils::PexprDisjunction(pmp, pdrgpexprExtract); GPOS_ASSERT(NULL != pexpr); GPOS_ASSERT(CUtils::FScalarConstFalse(pexpr)); pexpr->Release(); // collapse empty input array to disjunct CExpression *pexprSingleton = CPredicateUtils::PexprDisjunction(pmp, NULL /*pdrgpexpr*/); GPOS_ASSERT(NULL != pexprSingleton); pexprSingleton->Release(); pexprDisjunction->Release(); // disjunction on scalar comparisons CExpression *pexprGet = CTestUtils::PexprLogicalGet(pmp); CColRefSet *pcrs = CDrvdPropRelational::Pdprel(pexprGet->PdpDerive())->PcrsOutput(); CColRefSetIter crsi(*pcrs); #ifdef GPOS_DEBUG BOOL fAdvance = #endif crsi.FAdvance(); GPOS_ASSERT(fAdvance); CColRef *pcr1 = crsi.Pcr(); #ifdef GPOS_DEBUG fAdvance = #endif crsi.FAdvance(); GPOS_ASSERT(fAdvance); CColRef *pcr2 = crsi.Pcr(); #ifdef GPOS_DEBUG fAdvance = #endif crsi.FAdvance(); GPOS_ASSERT(fAdvance); CColRef *pcr3 = crsi.Pcr(); CExpression *pexprCmp1 = CUtils::PexprScalarCmp(pmp, pcr1, pcr2, IMDType::EcmptEq); CExpression *pexprCmp2 = CUtils::PexprScalarCmp(pmp, pcr1, CUtils::PexprScalarConstInt4(pmp, 1 /*iVal*/), IMDType::EcmptEq); { CExpression *pexprDisj = CPredicateUtils::PexprDisjunction(pmp, pexprCmp1, pexprCmp2); pdrgpexprExtract = CPredicateUtils::PdrgpexprDisjuncts(pmp, pexprDisj); GPOS_ASSERT(2 == pdrgpexprExtract->UlLength()); pdrgpexprExtract->Release(); pexprDisj->Release(); } { DrgPexpr *pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp); CExpression *pexprCmp3 = CUtils::PexprScalarCmp(pmp, pcr2, pcr1, IMDType::EcmptG); CExpression *pexprCmp4 = CUtils::PexprScalarCmp(pmp, CUtils::PexprScalarConstInt4(pmp, 200 /*iVal*/), pcr3, IMDType::EcmptL); pexprCmp1->AddRef(); pexprCmp2->AddRef(); pdrgpexpr->Append(pexprCmp3); pdrgpexpr->Append(pexprCmp4); pdrgpexpr->Append(pexprCmp1); pdrgpexpr->Append(pexprCmp2); CExpression *pexprDisj = CPredicateUtils::PexprDisjunction(pmp, pdrgpexpr); pdrgpexprExtract = CPredicateUtils::PdrgpexprDisjuncts(pmp, pexprDisj); GPOS_ASSERT(4 == pdrgpexprExtract->UlLength()); pdrgpexprExtract->Release(); pexprDisj->Release(); } pexprCmp1->Release(); pexprCmp2->Release(); pexprGet->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; }