//---------------------------------------------------------------------------
// @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:
// CMDAccessorTest::EresUnittest_Cast
//
// @doc:
// Test fetching cast objects from the MD cache
//
//---------------------------------------------------------------------------
GPOS_RESULT
CMDAccessorTest::EresUnittest_Cast()
{
CAutoMemoryPool amp;
IMemoryPool *mp = amp.Pmp();
CAutoTrace at(mp);
// Setup an MD cache with 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)
);
const IMDType *pmdtypeInt = mda.PtMDType<IMDTypeInt4>(CTestUtils::m_sysidDefault);
const IMDType *pmdtypeOid = mda.PtMDType<IMDTypeOid>(CTestUtils::m_sysidDefault);
const IMDType *pmdtypeBigInt = mda.PtMDType<IMDTypeInt8>(CTestUtils::m_sysidDefault);
#ifdef GPOS_DEBUG
const IMDCast *pmdcastInt2BigInt =
#endif // GPOS_DEBUG
mda.Pmdcast(pmdtypeInt->MDId(), pmdtypeBigInt->MDId());
GPOS_ASSERT(!pmdcastInt2BigInt->IsBinaryCoercible());
GPOS_ASSERT(pmdcastInt2BigInt->GetCastFuncMdId()->IsValid());
GPOS_ASSERT(pmdcastInt2BigInt->MdidSrc()->Equals(pmdtypeInt->MDId()));
GPOS_ASSERT(pmdcastInt2BigInt->MdidDest()->Equals(pmdtypeBigInt->MDId()));
#ifdef GPOS_DEBUG
const IMDCast *pmdcastInt2Oid =
#endif // GPOS_DEBUG
mda.Pmdcast(pmdtypeInt->MDId(), pmdtypeOid->MDId());
GPOS_ASSERT(pmdcastInt2Oid->IsBinaryCoercible());
GPOS_ASSERT(!pmdcastInt2Oid->GetCastFuncMdId()->IsValid());
#ifdef GPOS_DEBUG
const IMDCast *pmdcastOid2Int =
#endif // GPOS_DEBUG
mda.Pmdcast(pmdtypeOid->MDId(), pmdtypeInt->MDId());
GPOS_ASSERT(pmdcastOid2Int->IsBinaryCoercible());
GPOS_ASSERT(!pmdcastOid2Int->GetCastFuncMdId()->IsValid());
return GPOS_OK;
}
int main( int hola, char** file_name)
{
CvRect rect;
rect.x=121;rect.y=110;rect.width=814;rect.height=223;
erCerc cerc(135,293,25);
erEqualP equ(0);
erSmootP p1(BLUR,7),p2(MEDIAN,5);
erCannyP cann(355,355);
erAdThrP adp(THRESH_BINARY,AM_MEAN,49,119,255); //** < */
erMacroDropAnalysis mda("hump");
mda.defineParameters(rect,cerc,p1,p2,cann,adp,equ);
mda.doIt("hump_1.bmp");
return(0);
};
//---------------------------------------------------------------------------
// @function:
// CMDAccessorTest::EresUnittest_DatumGeneric
//
// @doc:
// Test asserting during an attempt to obtain a generic type from the cache
//
//---------------------------------------------------------------------------
GPOS_RESULT
CMDAccessorTest::EresUnittest_DatumGeneric()
{
CAutoMemoryPool amp;
IMemoryPool *mp = amp.Pmp();
// Setup an MD cache with a file-based provider
CMDProviderMemory *pmdp = CTestUtils::m_pmdpf;
pmdp->AddRef();
CMDAccessor mda(mp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp);
// attempt to obtain a generic type from the cache should assert
(void) mda.PtMDType<IMDTypeGeneric>();
return GPOS_FAILED;
}
//---------------------------------------------------------------------------
// @function:
// CCorrelatedExecutionTest::EresUnittest_RunAllPositiveTests
//
// @doc:
// Run all tests that are expected to pass without any exceptions
// for parsing DXL documents into DXL trees.
//
//---------------------------------------------------------------------------
GPOS_RESULT
CCorrelatedExecutionTest::EresUnittest_RunAllPositiveTests()
{
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)
);
// loop over all test files
for (ULONG ul = m_ulTestCounter; ul < GPOS_ARRAY_SIZE(rgszPositiveTests); ul++)
{
// TODO: 06/15/2012; enable plan matching
GPOS_RESULT eres =
CTestUtils::EresTranslate
(
pmp,
rgszPositiveTests[ul],
NULL /* plan file */,
true /*fIgnoreMismatch*/
);
m_ulTestCounter++;
if (GPOS_OK != eres)
{
return eres;
}
}
// reset test counter
m_ulTestCounter = 0;
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CMDAccessorTest::EresUnittest_Negative
//
// @doc:
// Test fetching non-existing metadata objects from the MD cache
//
//---------------------------------------------------------------------------
GPOS_RESULT
CMDAccessorTest::EresUnittest_Negative()
{
CAutoMemoryPool amp(CAutoMemoryPool::ElcNone);
IMemoryPool *mp = amp.Pmp();
// Setup an MD cache with a file-based provider
CMDProviderMemory *pmdp = CTestUtils::m_pmdpf;
pmdp->AddRef();
CMDAccessor mda(mp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp);
// lookup a non-existing objects
CMDIdGPDB *pmdidNonExistingObject = GPOS_NEW(mp) CMDIdGPDB(GPOPT_MDCACHE_TEST_OID /* OID */, 15 /* version */, 1 /* minor version */);
// call should result in an exception
(void) mda.RetrieveRel(pmdidNonExistingObject);
pmdidNonExistingObject->Release();
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CCostTest::EresUnittest_Params
//
// @doc:
// Cost model parameters
//
//---------------------------------------------------------------------------
GPOS_RESULT
CCostTest::EresUnittest_Params()
{
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)
);
TestParams(mp, false /*fCalibrated*/);
}
{
// install opt context in TLS
CAutoOptCtxt aoc
(
mp,
&mda,
NULL, /* pceeval */
GPOS_NEW(mp) CCostModelGPDB(mp, GPOPT_TEST_SEGMENTS)
);
TestParams(mp, true /*fCalibrated*/);
}
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CMDAccessorTest::EresUnittest_ScCmp
//
// @doc:
// Test fetching scalar comparison objects from the MD cache
//
//---------------------------------------------------------------------------
GPOS_RESULT
CMDAccessorTest::EresUnittest_ScCmp()
{
CAutoMemoryPool amp;
IMemoryPool *mp = amp.Pmp();
CAutoTrace at(mp);
// Setup an MD cache with 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)
);
const IMDType *pmdtypeInt = mda.PtMDType<IMDTypeInt4>(CTestUtils::m_sysidDefault);
const IMDType *pmdtypeBigInt = mda.PtMDType<IMDTypeInt8>(CTestUtils::m_sysidDefault);
#ifdef GPOS_DEBUG
const IMDScCmp *pmdScEqIntBigInt =
#endif // GPOS_DEBUG
mda.Pmdsccmp(pmdtypeInt->MDId(), pmdtypeBigInt->MDId(), IMDType::EcmptEq);
GPOS_ASSERT(IMDType::EcmptEq == pmdScEqIntBigInt->ParseCmpType());
GPOS_ASSERT(pmdScEqIntBigInt->GetLeftMdid()->Equals(pmdtypeInt->MDId()));
GPOS_ASSERT(pmdScEqIntBigInt->GetRightMdid()->Equals(pmdtypeBigInt->MDId()));
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:
// CCostTest::EresUnittest_Params
//
// @doc:
// Cost model parameters
//
//---------------------------------------------------------------------------
GPOS_RESULT
CCostTest::EresUnittest_Params()
{
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)
);
TestParams(pmp, false /*fCalibrated*/);
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CPredicateUtilsTest::EresUnittest_Implication
//
// @doc:
// Test removal of implied predicates
//
//---------------------------------------------------------------------------
GPOS_RESULT
CPredicateUtilsTest::EresUnittest_Implication()
{
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)
);
// generate a two cascaded joins
CWStringConst strName1(GPOS_WSZ_LIT("Rel1"));
CMDIdGPDB *pmdid1 = GPOS_NEW(mp) CMDIdGPDB(GPOPT_TEST_REL_OID1, 1, 1);
CTableDescriptor *ptabdesc1 = CTestUtils::PtabdescCreate(mp, 3, pmdid1, CName(&strName1));
CWStringConst strAlias1(GPOS_WSZ_LIT("Rel1"));
CExpression *pexprRel1 = CTestUtils::PexprLogicalGet(mp, ptabdesc1, &strAlias1);
CWStringConst strName2(GPOS_WSZ_LIT("Rel2"));
CMDIdGPDB *pmdid2 = GPOS_NEW(mp) CMDIdGPDB(GPOPT_TEST_REL_OID2, 1, 1);
CTableDescriptor *ptabdesc2 = CTestUtils::PtabdescCreate(mp, 3, pmdid2, CName(&strName2));
CWStringConst strAlias2(GPOS_WSZ_LIT("Rel2"));
CExpression *pexprRel2 = CTestUtils::PexprLogicalGet(mp, ptabdesc2, &strAlias2);
CWStringConst strName3(GPOS_WSZ_LIT("Rel3"));
CMDIdGPDB *pmdid3 = GPOS_NEW(mp) CMDIdGPDB(GPOPT_TEST_REL_OID3, 1, 1);
CTableDescriptor *ptabdesc3 = CTestUtils::PtabdescCreate(mp, 3, pmdid3, CName(&strName3));
CWStringConst strAlias3(GPOS_WSZ_LIT("Rel3"));
CExpression *pexprRel3 = CTestUtils::PexprLogicalGet(mp, ptabdesc3, &strAlias3);
CExpression *pexprJoin1 = CTestUtils::PexprLogicalJoin<CLogicalInnerJoin>(mp, pexprRel1, pexprRel2);
CExpression *pexprJoin2 = CTestUtils::PexprLogicalJoin<CLogicalInnerJoin>(mp, pexprJoin1, pexprRel3);
{
CAutoTrace at(mp);
at.Os() << "Original expression:" << std::endl << *pexprJoin2 <<std::endl;
}
// imply new predicates by deriving constraints
CExpression *pexprConstraints = CExpressionPreprocessor::PexprAddPredicatesFromConstraints(mp, pexprJoin2);
{
CAutoTrace at(mp);
at.Os() << "Expression with implied predicates:" << std::endl << *pexprConstraints <<std::endl;;
}
// minimize join predicates by removing implied conjuncts
CExpressionHandle exprhdl(mp);
exprhdl.Attach(pexprConstraints);
CExpression *pexprMinimizedPred = CPredicateUtils::PexprRemoveImpliedConjuncts(mp, (*pexprConstraints)[2], exprhdl);
{
CAutoTrace at(mp);
at.Os() << "Minimized join predicate:" << std::endl << *pexprMinimizedPred <<std::endl;
}
CExpressionArray *pdrgpexprOriginalConjuncts = CPredicateUtils::PdrgpexprConjuncts(mp, (*pexprConstraints)[2]);
CExpressionArray *pdrgpexprNewConjuncts = CPredicateUtils::PdrgpexprConjuncts(mp, pexprMinimizedPred);
GPOS_ASSERT(pdrgpexprNewConjuncts->Size() < pdrgpexprOriginalConjuncts->Size());
// clean up
pdrgpexprOriginalConjuncts->Release();
pdrgpexprNewConjuncts->Release();
pexprJoin2->Release();
pexprConstraints->Release();
pexprMinimizedPred->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 *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)
);
CExpression *pexprLeft = CTestUtils::PexprLogicalGet(mp);
CExpression *pexprRight = CTestUtils::PexprLogicalGet(mp);
CExpressionArray *pdrgpexprOriginal = GPOS_NEW(mp) CExpressionArray(mp);
CColRefSet *pcrsLeft = CDrvdPropRelational::GetRelationalProperties(pexprLeft->PdpDerive())->PcrsOutput();
CColRefSet *pcrsRight = CDrvdPropRelational::GetRelationalProperties(pexprRight->PdpDerive())->PcrsOutput();
CColRef *pcrLeft = pcrsLeft->PcrAny();
CColRef *pcrRight = pcrsRight->PcrAny();
// generate an equality predicate between two column reference
CExpression *pexprScIdentEquality =
CUtils::PexprScalarEqCmp(mp, pcrLeft, pcrRight);
pexprScIdentEquality->AddRef();
pdrgpexprOriginal->Append(pexprScIdentEquality);
// generate a non-equality predicate between two column reference
CExpression *pexprScIdentInequality =
CUtils::PexprScalarCmp(mp, pcrLeft, pcrRight, CWStringConst(GPOS_WSZ_LIT("<")), GPOS_NEW(mp) 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(mp, 10 /*fValue*/);
CExpression *pexprScIdentConstEquality = CUtils::PexprScalarEqCmp(mp, pexprScalarConstInt4, pcrRight);
pdrgpexprOriginal->Append(pexprScIdentConstEquality);
GPOS_ASSERT(3 == pdrgpexprOriginal->Size());
CExpressionArray *pdrgpexprResult = CPredicateUtils::PdrgpexprPlainEqualities(mp, pdrgpexprOriginal);
GPOS_ASSERT(1 == pdrgpexprResult->Size());
// 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 *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)
);
// build disjunction
CExpressionArray *pdrgpexpr = GPOS_NEW(mp) CExpressionArray(mp);
const ULONG ulDisjs = 3;
for (ULONG ul = 0; ul < ulDisjs; ul++)
{
pdrgpexpr->Append(CUtils::PexprScalarConstBool(mp, false /*fValue*/));
}
CExpression *pexprDisjunction = CUtils::PexprScalarBoolOp(mp, CScalarBoolOp::EboolopOr, pdrgpexpr);
// break into disjuncts
CExpressionArray *pdrgpexprExtract = CPredicateUtils::PdrgpexprDisjuncts(mp, pexprDisjunction);
GPOS_ASSERT(pdrgpexprExtract->Size() == ulDisjs);
// collapse into single disjunct
CExpression *pexpr = CPredicateUtils::PexprDisjunction(mp, pdrgpexprExtract);
GPOS_ASSERT(NULL != pexpr);
GPOS_ASSERT(CUtils::FScalarConstFalse(pexpr));
pexpr->Release();
// collapse empty input array to disjunct
CExpression *pexprSingleton = CPredicateUtils::PexprDisjunction(mp, NULL /*pdrgpexpr*/);
GPOS_ASSERT(NULL != pexprSingleton);
pexprSingleton->Release();
pexprDisjunction->Release();
// disjunction on scalar comparisons
CExpression *pexprGet = CTestUtils::PexprLogicalGet(mp);
CColRefSet *pcrs = CDrvdPropRelational::GetRelationalProperties(pexprGet->PdpDerive())->PcrsOutput();
CColRefSetIter crsi(*pcrs);
#ifdef GPOS_DEBUG
BOOL fAdvance =
#endif
crsi.Advance();
GPOS_ASSERT(fAdvance);
CColRef *pcr1 = crsi.Pcr();
#ifdef GPOS_DEBUG
fAdvance =
#endif
crsi.Advance();
GPOS_ASSERT(fAdvance);
CColRef *pcr2 = crsi.Pcr();
#ifdef GPOS_DEBUG
fAdvance =
#endif
crsi.Advance();
GPOS_ASSERT(fAdvance);
CColRef *pcr3 = crsi.Pcr();
CExpression *pexprCmp1 = CUtils::PexprScalarCmp(mp, pcr1, pcr2, IMDType::EcmptEq);
CExpression *pexprCmp2 = CUtils::PexprScalarCmp(mp, pcr1, CUtils::PexprScalarConstInt4(mp, 1 /*val*/), IMDType::EcmptEq);
{
CExpression *pexprDisj = CPredicateUtils::PexprDisjunction(mp, pexprCmp1, pexprCmp2);
pdrgpexprExtract = CPredicateUtils::PdrgpexprDisjuncts(mp, pexprDisj);
GPOS_ASSERT(2 == pdrgpexprExtract->Size());
pdrgpexprExtract->Release();
pexprDisj->Release();
}
{
CExpressionArray *pdrgpexpr = GPOS_NEW(mp) CExpressionArray(mp);
CExpression *pexprCmp3 = CUtils::PexprScalarCmp(mp, pcr2, pcr1, IMDType::EcmptG);
CExpression *pexprCmp4 = CUtils::PexprScalarCmp(mp, CUtils::PexprScalarConstInt4(mp, 200 /*val*/), pcr3, IMDType::EcmptL);
pexprCmp1->AddRef();
pexprCmp2->AddRef();
pdrgpexpr->Append(pexprCmp3);
pdrgpexpr->Append(pexprCmp4);
pdrgpexpr->Append(pexprCmp1);
pdrgpexpr->Append(pexprCmp2);
CExpression *pexprDisj = CPredicateUtils::PexprDisjunction(mp, pdrgpexpr);
pdrgpexprExtract = CPredicateUtils::PdrgpexprDisjuncts(mp, pexprDisj);
GPOS_ASSERT(4 == pdrgpexprExtract->Size());
pdrgpexprExtract->Release();
pexprDisj->Release();
}
pexprCmp1->Release();
pexprCmp2->Release();
pexprGet->Release();
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CMDAccessorTest::PvInitMDAAndLookup
//
// @doc:
// Task which initializes a MD accessor and looks up multiple objects through
// that accessor
//
//---------------------------------------------------------------------------
void *
CMDAccessorTest::PvInitMDAAndLookup
(
void * pv
)
{
GPOS_ASSERT(NULL != pv);
CMDAccessor::MDCache *pcache = (CMDAccessor::MDCache *) pv;
CAutoMemoryPool amp;
IMemoryPool *mp = amp.Pmp();
CWorkerPoolManager *pwpm = CWorkerPoolManager::WorkerPoolManager();
// task memory pool
CAutoMemoryPool ampTask;
IMemoryPool *pmpTask = ampTask.Pmp();
// scope for MD accessor
{
// Setup an MD cache with a file-based provider
CMDProviderMemory *pmdp = CTestUtils::m_pmdpf;
pmdp->AddRef();
CMDAccessor mda(mp, pcache, CTestUtils::m_sysidDefault, pmdp);
// task parameters
SMDCacheTaskParams mdtaskparams(pmpTask, &mda);
// scope for ATP
{
CAutoTaskProxy atp(mp, pwpm);
CTask *rgPtsk[GPOPT_MDCACHE_LOOKUP_THREADS];
TaskFuncPtr rgPfuncTask[] =
{
CMDAccessorTest::PvLookupSingleObj,
CMDAccessorTest::PvLookupMultipleObj
};
const ULONG ulNumberOfTaskTypes = GPOS_ARRAY_SIZE(rgPfuncTask);
// create tasks
for (ULONG i = 0; i < GPOS_ARRAY_SIZE(rgPtsk); i++)
{
rgPtsk[i] = atp.Create
(
rgPfuncTask[i % ulNumberOfTaskTypes],
&mdtaskparams
);
GPOS_CHECK_ABORT;
}
for (ULONG i = 0; i < GPOS_ARRAY_SIZE(rgPtsk); i++)
{
atp.Schedule(rgPtsk[i]);
}
GPOS_CHECK_ABORT;
// wait for completion
for (ULONG i = 0; i < GPOS_ARRAY_SIZE(rgPtsk); i++)
{
atp.Wait(rgPtsk[i]);
GPOS_CHECK_ABORT;
}
}
}
return NULL;
}
//---------------------------------------------------------------------------
// @function:
// CMDAccessorTest::EresUnittest_ConcurrentAccessSingleMDA
//
// @doc:
// Test concurrent access through a single MD accessor from different threads
//
//---------------------------------------------------------------------------
GPOS_RESULT
CMDAccessorTest::EresUnittest_ConcurrentAccessSingleMDA()
{
CAutoMemoryPool amp;
IMemoryPool *mp = amp.Pmp();
CWorkerPoolManager *pwpm = CWorkerPoolManager::WorkerPoolManager();
// task memory pool
CAutoMemoryPool ampTask;
IMemoryPool *pmpTask = ampTask.Pmp();
// setup a file-based provider
// Setup an MD cache with a file-based provider
CMDProviderMemory *pmdp = CTestUtils::m_pmdpf;
pmdp->AddRef();
CMDAccessor mda(mp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp);
// task parameters
SMDCacheTaskParams mdtaskparams(pmpTask, &mda);
// scope for ATP
{
CAutoTaskProxy atp(mp, pwpm);
CTask *rgPtsk[GPOPT_MDCACHE_LOOKUP_THREADS];
TaskFuncPtr rgPfuncTask[] =
{
CMDAccessorTest::PvLookupSingleObj,
CMDAccessorTest::PvLookupMultipleObj
};
const ULONG ulNumberOfTaskTypes = GPOS_ARRAY_SIZE(rgPfuncTask);
// create tasks
for (ULONG i = 0; i < GPOS_ARRAY_SIZE(rgPtsk); i++)
{
rgPtsk[i] = atp.Create
(
rgPfuncTask[i % ulNumberOfTaskTypes],
&mdtaskparams
);
GPOS_CHECK_ABORT;
}
for (ULONG i = 0; i < GPOPT_MDCACHE_LOOKUP_THREADS; i++)
{
atp.Schedule(rgPtsk[i]);
}
GPOS_CHECK_ABORT;
// wait for completion
for (ULONG i = 0; i < GPOS_ARRAY_SIZE(rgPtsk); i++)
{
atp.Wait(rgPtsk[i]);
GPOS_CHECK_ABORT;
}
}
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CMDAccessorTest::EresUnittest_Basic
//
// @doc:
// Test fetching metadata objects from a metadata cache
//
//---------------------------------------------------------------------------
GPOS_RESULT
CMDAccessorTest::EresUnittest_Basic()
{
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)
);
// lookup different objects
CMDIdGPDB *pmdidObject1 = GPOS_NEW(mp) CMDIdGPDB(GPOPT_MDCACHE_TEST_OID /* OID */, 1 /* major version */, 1 /* minor version */);
CMDIdGPDB *pmdidObject2 = GPOS_NEW(mp) CMDIdGPDB(GPOPT_MDCACHE_TEST_OID /* OID */, 12 /* version */, 1 /* minor version */);
#ifdef GPOS_DEBUG
const IMDRelation *pimdrel1 =
#endif
mda.RetrieveRel(pmdidObject1);
#ifdef GPOS_DEBUG
const IMDRelation *pimdrel2 =
#endif
mda.RetrieveRel(pmdidObject2);
GPOS_ASSERT(pimdrel1->MDId()->Equals(pmdidObject1) && pimdrel2->MDId()->Equals(pmdidObject2));
// access an object again
#ifdef GPOS_DEBUG
const IMDRelation *pimdrel3 =
#endif
mda.RetrieveRel(pmdidObject1);
GPOS_ASSERT(pimdrel1 == pimdrel3);
// access GPDB types, operators and aggregates
CMDIdGPDB *mdid_type = GPOS_NEW(mp) CMDIdGPDB(GPDB_INT4, 1, 0);
CMDIdGPDB *mdid_op = GPOS_NEW(mp) CMDIdGPDB(GPDB_OP_INT4_LT, 1, 0);
CMDIdGPDB *agg_mdid = GPOS_NEW(mp) CMDIdGPDB(GPDB_AGG_AVG, 1, 0);
#ifdef GPOS_DEBUG
const IMDType *pimdtype =
#endif
mda.RetrieveType(mdid_type);
#ifdef GPOS_DEBUG
const IMDScalarOp *md_scalar_op =
#endif
mda.RetrieveScOp(mdid_op);
GPOS_ASSERT(IMDType::EcmptL == md_scalar_op->ParseCmpType());
#ifdef GPOS_DEBUG
const IMDAggregate *pmdagg =
#endif
mda.RetrieveAgg(agg_mdid);
// access types by type info
#ifdef GPOS_DEBUG
const IMDTypeInt4 *pmdtypeint4 =
#endif
mda.PtMDType<IMDTypeInt4>(CTestUtils::m_sysidDefault);
#ifdef GPOS_DEBUG
const IMDTypeBool *pmdtypebool =
#endif
mda.PtMDType<IMDTypeBool>(CTestUtils::m_sysidDefault);
#ifdef GPOS_DEBUG
// for debug traces
CAutoTrace at(mp);
IOstream &os(at.Os());
// print objects
os << std::endl;
pimdrel1->DebugPrint(os);
os << std::endl;
pimdrel2->DebugPrint(os);
os << std::endl;
pimdtype->DebugPrint(os);
os << std::endl;
md_scalar_op->DebugPrint(os);
os << std::endl;
pmdagg->DebugPrint(os);
os << std::endl;
pmdtypeint4->DebugPrint(os);
os << std::endl;
pmdtypebool->DebugPrint(os);
os << std::endl;
#endif
pmdidObject1->Release();
pmdidObject2->Release();
agg_mdid->Release();
mdid_op->Release();
mdid_type->Release();
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CCostTest::EresUnittest_CalibratedCostModel
//
// @doc:
// GPDB's calibrated cost model test
//
//---------------------------------------------------------------------------
GPOS_RESULT
CCostTest::EresUnittest_CalibratedCostModel()
{
CAutoTraceFlag atf1(EtraceSimulateOOM, false);
CAutoTraceFlag atf2(EtraceSimulateAbort, false);
CAutoTraceFlag atf3(EtraceSimulateIOError, false);
CAutoTraceFlag atf4(EtraceSimulateNetError, false);
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);
ICostModel *pcm = GPOS_NEW(pmp) CCostModelGPDB(pmp, GPOPT_TEST_SEGMENTS);
pcm->AddRef();
{
// install opt context in TLS
CAutoOptCtxt aoc
(
pmp,
&mda,
NULL, /* pceeval */
pcm
);
TestParams(pmp, true /*fCalibrated*/);
}
// minidump files
const CHAR *rgszFileNamesCalibratedCostModel[] =
{
"../data/dxl/minidump/PartTbl-MultiWayJoinWithDPE.mdp",
"../data/dxl/tpch/q2.mdp",
"../data/dxl/minidump/CTE-4.mdp",
"../data/dxl/minidump/Lead-Lag-WinFuncs.mdp",
};
COptimizerConfig* poconf = COptimizerConfig::PoconfDefault(pmp, pcm);
for (ULONG ul = 0; ul < GPOS_ARRAY_SIZE(rgszFileNamesCalibratedCostModel); ul++)
{
CDXLNode *pdxlnPlan = CMinidumperUtils::PdxlnExecuteMinidump
(
pmp,
rgszFileNamesCalibratedCostModel[ul],
GPOPT_TEST_SEGMENTS,
1 /*ulSessionId*/,
1 /*ulCmdId*/,
poconf,
NULL /*pceeval*/
);
pdxlnPlan->Release();
}
poconf->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:
// 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:
// CCostTest::EresUnittest_SetParams
//
// @doc:
// Test of setting cost model params
//
//---------------------------------------------------------------------------
GPOS_RESULT
CCostTest::EresUnittest_SetParams()
{
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);
ICostModel *pcm = GPOS_NEW(mp) CCostModelGPDB(mp, GPOPT_TEST_SEGMENTS);
// install opt context in TLS
CAutoOptCtxt aoc(mp, &mda, NULL, /* pceeval */ pcm);
// generate in-equality join expression
CExpression *pexprOuter = CTestUtils::PexprLogicalGet(mp);
const CColRef *pcrOuter = CDrvdPropRelational::GetRelationalProperties(pexprOuter->PdpDerive())->PcrsOutput()->PcrAny();
CExpression *pexprInner = CTestUtils::PexprLogicalGet(mp);
const CColRef *pcrInner = CDrvdPropRelational::GetRelationalProperties(pexprInner->PdpDerive())->PcrsOutput()->PcrAny();
CExpression *pexprPred = CUtils::PexprScalarCmp(mp, pcrOuter, pcrInner, IMDType::EcmptNEq);
CExpression *pexpr = CUtils::PexprLogicalJoin<CLogicalInnerJoin>(mp, pexprOuter, pexprInner, pexprPred);
// optimize in-equality join based on default cost model params
CExpression *pexprPlan1 = NULL;
{
CEngine eng(mp);
// generate query context
CQueryContext *pqc = CTestUtils::PqcGenerate(mp, pexpr);
// Initialize engine
eng.Init(pqc, NULL /*search_stage_array*/);
// optimize query
eng.Optimize();
// extract plan
pexprPlan1 = eng.PexprExtractPlan();
GPOS_ASSERT(NULL != pexprPlan1);
GPOS_DELETE(pqc);
}
// change NLJ cost factor
ICostModelParams::SCostParam *pcp = pcm->GetCostModelParams()->PcpLookup(CCostModelParamsGPDB::EcpNLJFactor);
CDouble dNLJFactor = CDouble(2.0);
CDouble dVal = pcp->Get() * dNLJFactor;
pcm->GetCostModelParams()->SetParam(pcp->Id(), dVal, dVal - 0.5, dVal + 0.5);
// optimize again after updating NLJ cost factor
CExpression *pexprPlan2 = NULL;
{
CEngine eng(mp);
// generate query context
CQueryContext *pqc = CTestUtils::PqcGenerate(mp, pexpr);
// Initialize engine
eng.Init(pqc, NULL /*search_stage_array*/);
// optimize query
eng.Optimize();
// extract plan
pexprPlan2 = eng.PexprExtractPlan();
GPOS_ASSERT(NULL != pexprPlan2);
GPOS_DELETE(pqc);
}
{
CAutoTrace at(mp);
at.Os() << "\nPLAN1: \n" << *pexprPlan1;
at.Os() << "\nNLJ Cost1: " << (*pexprPlan1)[0]->Cost();
at.Os() << "\n\nPLAN2: \n" << *pexprPlan2;
at.Os() << "\nNLJ Cost2: " << (*pexprPlan2)[0]->Cost();
}
GPOS_ASSERT((*pexprPlan2)[0]->Cost() >= (*pexprPlan1)[0]->Cost() * dNLJFactor &&
"expected NLJ cost in PLAN2 to be larger than NLJ cost in PLAN1");
// clean up
pexpr->Release();
pexprPlan1->Release();
pexprPlan2->Release();
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:
// 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:
// 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:
// CPredicateUtilsTest::EresUnittest_Conjunctions
//
// @doc:
// Test extraction and construction of conjuncts
//
//---------------------------------------------------------------------------
GPOS_RESULT
CPredicateUtilsTest::EresUnittest_Conjunctions()
{
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)
);
// build conjunction
CExpressionArray *pdrgpexpr = GPOS_NEW(mp) CExpressionArray(mp);
const ULONG ulConjs = 3;
for (ULONG ul = 0; ul < ulConjs; ul++)
{
pdrgpexpr->Append(CUtils::PexprScalarConstBool(mp, true /*fValue*/));
}
CExpression *pexprConjunction = CUtils::PexprScalarBoolOp(mp, CScalarBoolOp::EboolopAnd, pdrgpexpr);
// break into conjuncts
CExpressionArray *pdrgpexprExtract = CPredicateUtils::PdrgpexprConjuncts(mp, pexprConjunction);
GPOS_ASSERT(pdrgpexprExtract->Size() == ulConjs);
// collapse into single conjunct
CExpression *pexpr = CPredicateUtils::PexprConjunction(mp, pdrgpexprExtract);
GPOS_ASSERT(NULL != pexpr);
GPOS_ASSERT(CUtils::FScalarConstTrue(pexpr));
pexpr->Release();
// collapse empty input array to conjunct
CExpression *pexprSingleton = CPredicateUtils::PexprConjunction(mp, NULL /*pdrgpexpr*/);
GPOS_ASSERT(NULL != pexprSingleton);
pexprSingleton->Release();
pexprConjunction->Release();
// conjunction on scalar comparisons
CExpression *pexprGet = CTestUtils::PexprLogicalGet(mp);
CColRefSet *pcrs = CDrvdPropRelational::GetRelationalProperties(pexprGet->PdpDerive())->PcrsOutput();
CColRef *pcr1 = pcrs->PcrAny();
CColRef *pcr2 = pcrs->PcrFirst();
CExpression *pexprCmp1 = CUtils::PexprScalarCmp(mp, pcr1, pcr2, IMDType::EcmptEq);
CExpression *pexprCmp2 = CUtils::PexprScalarCmp(mp, pcr1, CUtils::PexprScalarConstInt4(mp, 1 /*val*/), IMDType::EcmptEq);
CExpression *pexprConj = CPredicateUtils::PexprConjunction(mp, pexprCmp1, pexprCmp2);
pdrgpexprExtract = CPredicateUtils::PdrgpexprConjuncts(mp, pexprConj);
GPOS_ASSERT(2 == pdrgpexprExtract->Size());
pdrgpexprExtract->Release();
pexprCmp1->Release();
pexprCmp2->Release();
pexprConj->Release();
pexprGet->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:
// 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:
// CMDAccessorTest::EresUnittest_Indexes
//
// @doc:
// Test fetching indexes from the cache
//
//---------------------------------------------------------------------------
GPOS_RESULT
CMDAccessorTest::EresUnittest_Indexes()
{
CAutoMemoryPool amp;
IMemoryPool *mp = amp.Pmp();
CAutoTrace at(mp);
#ifdef GPOS_DEBUG
IOstream &os(at.Os());
#endif // GPOS_DEBUG
// Setup an MD cache with 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)
);
// lookup a relation in the MD cache
CMDIdGPDB *rel_mdid = GPOS_NEW(mp) CMDIdGPDB(GPOPT_MDCACHE_TEST_OID, 1 /* major */, 1 /* minor version */);
const IMDRelation *pmdrel = mda.RetrieveRel(rel_mdid);
GPOS_ASSERT(0 < pmdrel->IndexCount());
IMDId *pmdidIndex = pmdrel->IndexMDidAt(0);
const IMDIndex *pmdindex = mda.RetrieveIndex(pmdidIndex);
ULONG ulKeys = pmdindex->Keys();
#ifdef GPOS_DEBUG
// print index
pmdindex->DebugPrint(os);
os << std::endl;
os << "Index columns: " << std::endl;
#endif // GPOS_DEBUG
for (ULONG ul = 0; ul < ulKeys; ul++)
{
ULONG ulKeyColumn = pmdindex->KeyAt(ul);
#ifdef GPOS_DEBUG
const IMDColumn *pmdcol =
#endif // GPOS_DEBUG
pmdrel->GetMdCol(ulKeyColumn);
#ifdef GPOS_DEBUG
pmdcol->DebugPrint(os);
#endif // GPOS_DEBUG
}
rel_mdid->Release();
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @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:
// COrderSpecTest::EresUnittest_Basics
//
// @doc:
// Basic order spec tests
//
//---------------------------------------------------------------------------
GPOS_RESULT
COrderSpecTest::EresUnittest_Basics()
{
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)
);
// get column factory from optimizer context object
CColumnFactory *pcf = COptCtxt::PoctxtFromTLS()->Pcf();
CWStringConst strName(GPOS_WSZ_LIT("Test Column"));
CName name(&strName);
const IMDTypeInt4 *pmdtypeint4 = mda.PtMDType<IMDTypeInt4>(CTestUtils::m_sysidDefault);
CColRef *pcr1 = pcf->PcrCreate(pmdtypeint4, name);
CColRef *pcr2 = pcf->PcrCreate(pmdtypeint4, name);
CColRef *pcr3 = pcf->PcrCreate(pmdtypeint4, name);
COrderSpec *pos1 = GPOS_NEW(pmp) COrderSpec(pmp);
IMDId *pmdidInt4LT = pmdtypeint4->PmdidCmp(IMDType::EcmptL);
pmdidInt4LT->AddRef();
pmdidInt4LT->AddRef();
pos1->Append(pmdidInt4LT, pcr1, COrderSpec::EntFirst);
pos1->Append(pmdidInt4LT, pcr2, COrderSpec::EntLast);
GPOS_ASSERT(pos1->FMatch(pos1));
GPOS_ASSERT(pos1->FSatisfies(pos1));
COrderSpec *pos2 = GPOS_NEW(pmp) COrderSpec(pmp);
pmdidInt4LT->AddRef();
pmdidInt4LT->AddRef();
pmdidInt4LT->AddRef();
pos2->Append(pmdidInt4LT, pcr1, COrderSpec::EntFirst);
pos2->Append(pmdidInt4LT, pcr2, COrderSpec::EntLast);
pos2->Append(pmdidInt4LT, pcr3, COrderSpec::EntAuto);
(void) pos1->UlHash();
(void) pos2->UlHash();
GPOS_ASSERT(pos2->FMatch(pos2));
GPOS_ASSERT(pos2->FSatisfies(pos2));
GPOS_ASSERT(!pos1->FMatch(pos2));
GPOS_ASSERT(!pos2->FMatch(pos1));
GPOS_ASSERT(pos2->FSatisfies(pos1));
GPOS_ASSERT(!pos1->FSatisfies(pos2));
// iterate over the components of the order spec
for (ULONG ul = 0; ul < pos1->UlSortColumns(); ul++)
{
#ifdef GPOS_DEBUG
const CColRef *pcr =
#endif // GPOS_DEBUG
pos1->Pcr(ul);
GPOS_ASSERT(NULL != pcr);
#ifdef GPOS_DEBUG
const IMDId *pmdid =
#endif // GPOS_DEBUG
pos1->PmdidSortOp(ul);
GPOS_ASSERT(pmdid->FValid());
(void) pos1->Ent(ul);
}
pos1->Release();
pos2->Release();
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CMDAccessorTest::EresUnittest_IndexPartConstraint
//
// @doc:
// Test fetching part constraints for indexes on partitioned tables
//
//---------------------------------------------------------------------------
GPOS_RESULT
CMDAccessorTest::EresUnittest_IndexPartConstraint()
{
CAutoMemoryPool amp;
IMemoryPool *mp = amp.Pmp();
CAutoTrace at(mp);
// Setup an MD cache with 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)
);
CColumnFactory *col_factory = COptCtxt::PoctxtFromTLS()->Pcf();
// lookup a relation in the MD cache
CMDIdGPDB *rel_mdid = GPOS_NEW(mp) CMDIdGPDB(GPOPT_TEST_REL_OID22);
const IMDRelation *pmdrel = mda.RetrieveRel(rel_mdid);
GPOS_ASSERT(0 < pmdrel->IndexCount());
// create the array of column reference for the table columns
// for the DXL to Expr translation
CColRefArray *colref_array = GPOS_NEW(mp) CColRefArray(mp);
const ULONG num_cols = pmdrel->ColumnCount() - pmdrel->SystemColumnsCount();
for (ULONG ul = 0; ul < num_cols; ul++)
{
const IMDColumn *pmdcol = pmdrel->GetMdCol(ul);
const IMDType *pmdtype = mda.RetrieveType(pmdcol->MdidType());
CColRef *colref = col_factory->PcrCreate(pmdtype, pmdcol->TypeModifier());
colref_array->Append(colref);
}
// get one of its indexes
GPOS_ASSERT(0 < pmdrel->IndexCount());
IMDId *pmdidIndex = pmdrel->IndexMDidAt(0);
const IMDIndex *pmdindex = mda.RetrieveIndex(pmdidIndex);
// extract and then print the part constraint expression
IMDPartConstraint *mdpart_constraint = pmdindex->MDPartConstraint();
GPOS_ASSERT(NULL != mdpart_constraint);
CExpression *pexpr = mdpart_constraint->GetPartConstraintExpr(mp, &mda, colref_array);
#ifdef GPOS_DEBUG
IOstream &os(at.Os());
pexpr->DbgPrint();
os << std::endl;
#endif // GPOS_DEBUG
// clean up
pexpr->Release();
colref_array->Release();
rel_mdid->Release();
return GPOS_OK;
}
