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