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