//---------------------------------------------------------------------------
// @function:
// CMDProviderTest::EresUnittest_Negative
//
// @doc:
// Test fetching non-exiting metadata objects from a file-based provider
//
//---------------------------------------------------------------------------
GPOS_RESULT
CMDProviderTest::EresUnittest_Negative()
{
CAutoMemoryPool amp(CAutoMemoryPool::ElcNone);
IMemoryPool *mp = amp.Pmp();
CMDProviderMemory *pmdpFile = GPOS_NEW(mp) CMDProviderMemory(mp, file_name);
pmdpFile->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();
{
CAutoMDAccessor amda(mp, pmdpFile, CTestUtils::m_sysidDefault, pcache);
// lookup a non-existing objects
CMDIdGPDB *mdid = GPOS_NEW(mp) CMDIdGPDB(GPOPT_MDCACHE_TEST_OID, 15 /* major version */, 1 /* minor version */);
// call should result in an exception
(void) pmdpFile->GetMDObjDXLStr(mp, amda.Pmda(), mdid);
}
return GPOS_FAILED;
}
//---------------------------------------------------------------------------
// @function:
// CColumnFactoryTest::EresUnittest_Basic
//
// @doc:
// Basic array allocation test
//
//---------------------------------------------------------------------------
GPOS_RESULT
CColumnFactoryTest::EresUnittest_Basic()
{
CAutoMemoryPool amp;
IMemoryPool *pmp = amp.Pmp();
CMDProviderMemory *pmdp = CTestUtils::m_pmdpf;
pmdp->AddRef();
CMDAccessor mda(pmp, CMDCache::Pcache());
mda.RegisterProvider(CTestUtils::m_sysidDefault, pmdp);
const IMDTypeInt4 *pmdtypeint4 = mda.PtMDType<IMDTypeInt4>();
CColumnFactory cf;
// typed colref
CColRef *pcrOne = cf.PcrCreate(pmdtypeint4);
GPOS_ASSERT(pcrOne == cf.PcrLookup(pcrOne->m_ulId));
cf.Destroy(pcrOne);
// typed/named colref
CWStringConst strName(GPOS_WSZ_LIT("C_CustKey"));
CColRef *pcrTwo = cf.PcrCreate(pmdtypeint4, CName(&strName));
GPOS_ASSERT(pcrTwo == cf.PcrLookup(pcrTwo->m_ulId));
// clone previous colref
CColRef *pcrThree = cf.PcrCreate(pcrTwo);
GPOS_ASSERT(pcrThree != cf.PcrLookup(pcrTwo->m_ulId));
GPOS_ASSERT(!pcrThree->Name().FEquals(pcrTwo->Name()));
cf.Destroy(pcrThree);
cf.Destroy(pcrTwo);
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @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:
// 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;
}
//---------------------------------------------------------------------------
// @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:
// CMDProviderTest::EresUnittest_Stats
//
// @doc:
// Test fetching existing stats objects from a file-based provider
//
//---------------------------------------------------------------------------
GPOS_RESULT
CMDProviderTest::EresUnittest_Stats()
{
// create memory pool
CAutoMemoryPool amp;
IMemoryPool *mp = amp.Pmp();
CMDProviderMemory *pmdpFile = GPOS_NEW(mp) CMDProviderMemory(mp, file_name);
{
pmdpFile->AddRef();
CAutoMDAccessor amda(mp, pmdpFile, CTestUtils::m_sysidDefault, CMDCache::Pcache());
// lookup different objects
CMDIdRelStats *rel_stats_mdid = GPOS_NEW(mp) CMDIdRelStats(GPOS_NEW(mp) CMDIdGPDB(GPOPT_MDCACHE_TEST_OID, 1, 1));
CWStringBase *pstrRelStats = pmdpFile->GetMDObjDXLStr(mp, amda.Pmda(), rel_stats_mdid);
GPOS_ASSERT(NULL != pstrRelStats);
IMDCacheObject *pmdobjRelStats = CDXLUtils::ParseDXLToIMDIdCacheObj(mp, pstrRelStats, NULL);
GPOS_ASSERT(NULL != pmdobjRelStats);
CMDIdColStats *mdid_col_stats =
GPOS_NEW(mp) CMDIdColStats(GPOS_NEW(mp) CMDIdGPDB(GPOPT_MDCACHE_TEST_OID, 1, 1), 1 /* attno */);
CWStringBase *pstrColStats = pmdpFile->GetMDObjDXLStr(mp, amda.Pmda(), mdid_col_stats);
GPOS_ASSERT(NULL != pstrColStats);
IMDCacheObject *pmdobjColStats = CDXLUtils::ParseDXLToIMDIdCacheObj(mp, pstrColStats, NULL);
GPOS_ASSERT(NULL != pmdobjColStats);
// cleanup
rel_stats_mdid->Release();
mdid_col_stats->Release();
GPOS_DELETE(pstrRelStats);
GPOS_DELETE(pstrColStats);
pmdobjRelStats->Release();
pmdobjColStats->Release();
}
pmdpFile->Release();
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CMDProviderTest::EresUnittest_Stats
//
// @doc:
// Test fetching existing stats objects from a file-based provider
//
//---------------------------------------------------------------------------
GPOS_RESULT
CMDProviderTest::EresUnittest_Stats()
{
// create memory pool
CAutoMemoryPool amp;
IMemoryPool *pmp = amp.Pmp();
CMDProviderMemory *pmdpFile = GPOS_NEW(pmp) CMDProviderMemory(pmp, szFileName);
{
pmdpFile->AddRef();
CAutoMDAccessor amda(pmp, pmdpFile, CTestUtils::m_sysidDefault, CMDCache::Pcache());
// lookup different objects
CMDIdRelStats *pmdidRelStats = GPOS_NEW(pmp) CMDIdRelStats(GPOS_NEW(pmp) CMDIdGPDB(GPOPT_MDCACHE_TEST_OID, 1, 1));
CWStringBase *pstrRelStats = pmdpFile->PstrObject(pmp, amda.Pmda(), pmdidRelStats);
GPOS_ASSERT(NULL != pstrRelStats);
IMDCacheObject *pmdobjRelStats = CDXLUtils::PimdobjParseDXL(pmp, pstrRelStats, NULL);
GPOS_ASSERT(NULL != pmdobjRelStats);
CMDIdColStats *pmdidColStats =
GPOS_NEW(pmp) CMDIdColStats(GPOS_NEW(pmp) CMDIdGPDB(GPOPT_MDCACHE_TEST_OID, 1, 1), 1 /* ulAttno */);
CWStringBase *pstrColStats = pmdpFile->PstrObject(pmp, amda.Pmda(), pmdidColStats);
GPOS_ASSERT(NULL != pstrColStats);
IMDCacheObject *pmdobjColStats = CDXLUtils::PimdobjParseDXL(pmp, pstrColStats, NULL);
GPOS_ASSERT(NULL != pmdobjColStats);
// cleanup
pmdidRelStats->Release();
pmdidColStats->Release();
GPOS_DELETE(pstrRelStats);
GPOS_DELETE(pstrColStats);
pmdobjRelStats->Release();
pmdobjColStats->Release();
}
pmdpFile->Release();
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:
// CMDProviderTest::EresUnittest_Basic
//
// @doc:
// Test fetching existing metadata objects from a file-based provider
//
//---------------------------------------------------------------------------
GPOS_RESULT
CMDProviderTest::EresUnittest_Basic()
{
// create memory pool
CAutoMemoryPool amp;
IMemoryPool *pmp = amp.Pmp();
// test lookup with a file-based provider
CMDProviderMemory *pmdpFile = GPOS_NEW(pmp) CMDProviderMemory(pmp, szFileName);
pmdpFile->AddRef();
TestMDLookup(pmp, pmdpFile);
pmdpFile->Release();
// test lookup with a memory-based provider
CHAR *szDXL = CDXLUtils::SzRead(pmp, szFileName);
DrgPimdobj *pdrgpmdobj = CDXLUtils::PdrgpmdobjParseDXL(pmp, szDXL, NULL /*szXSDPath*/);
CMDProviderMemory *pmdpMemory = GPOS_NEW(pmp) CMDProviderMemory(pmp, pdrgpmdobj);
pmdpMemory->AddRef();
TestMDLookup(pmp, pmdpMemory);
GPOS_DELETE_ARRAY(szDXL);
pdrgpmdobj->Release();
pmdpMemory->Release();
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CMDProviderTest::EresUnittest_Basic
//
// @doc:
// Test fetching existing metadata objects from a file-based provider
//
//---------------------------------------------------------------------------
GPOS_RESULT
CMDProviderTest::EresUnittest_Basic()
{
// create memory pool
CAutoMemoryPool amp;
IMemoryPool *mp = amp.Pmp();
// test lookup with a file-based provider
CMDProviderMemory *pmdpFile = GPOS_NEW(mp) CMDProviderMemory(mp, file_name);
pmdpFile->AddRef();
TestMDLookup(mp, pmdpFile);
pmdpFile->Release();
// test lookup with a memory-based provider
CHAR *dxl_string = CDXLUtils::Read(mp, file_name);
IMDCacheObjectArray *mdcache_obj_array = CDXLUtils::ParseDXLToIMDObjectArray(mp, dxl_string, NULL /*xsd_file_path*/);
CMDProviderMemory *pmdpMemory = GPOS_NEW(mp) CMDProviderMemory(mp, mdcache_obj_array);
pmdpMemory->AddRef();
TestMDLookup(mp, pmdpMemory);
GPOS_DELETE_ARRAY(dxl_string);
mdcache_obj_array->Release();
pmdpMemory->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;
}
// unittest for statistics objects
GPOS_RESULT
CPointTest::EresUnittest()
{
// tests that use shared optimization context
CUnittest rgutSharedOptCtxt[] =
{
GPOS_UNITTEST_FUNC(CPointTest::EresUnittest_CPointInt4),
GPOS_UNITTEST_FUNC(CPointTest::EresUnittest_CPointBool),
};
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));
return CUnittest::EresExecute(rgutSharedOptCtxt, GPOS_ARRAY_SIZE(rgutSharedOptCtxt));
}
//---------------------------------------------------------------------------
// @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:
// 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:
// 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:
// 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:
// 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:
// 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_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:
// 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:
// 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;
}
