//---------------------------------------------------------------------------
// @function:
// CLogical::PdrgpcrCreateMapping
//
// @doc:
// Create output column mapping given a list of column descriptors and
// a pointer to the operator creating that column
//
//---------------------------------------------------------------------------
DrgPcr *
CLogical::PdrgpcrCreateMapping
(
IMemoryPool *pmp,
const DrgPcoldesc *pdrgpcoldesc,
ULONG ulOpSourceId
)
const
{
// get column factory from optimizer context object
CColumnFactory *pcf = COptCtxt::PoctxtFromTLS()->Pcf();
ULONG ulCols = pdrgpcoldesc->UlLength();
DrgPcr *pdrgpcr = GPOS_NEW(pmp) DrgPcr(pmp, ulCols);
for(ULONG ul = 0; ul < ulCols; ul++)
{
CColumnDescriptor *pcoldesc = (*pdrgpcoldesc)[ul];
CName name(pmp, pcoldesc->Name());
CColRef *pcr = pcf->PcrCreate(pcoldesc, name, ulOpSourceId);
pdrgpcr->Append(pcr);
}
return pdrgpcr;
}
//---------------------------------------------------------------------------
// @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:
// CQueryContext::PqcGenerate
//
// @doc:
// Generate the query context for the given expression and array of
// output column ref ids
//
//---------------------------------------------------------------------------
CQueryContext *
CQueryContext::PqcGenerate
(
IMemoryPool *pmp,
CExpression * pexpr,
DrgPul *pdrgpulQueryOutputColRefId,
DrgPmdname *pdrgpmdname,
BOOL fDeriveStats
)
{
GPOS_ASSERT(NULL != pexpr && NULL != pdrgpulQueryOutputColRefId);
CColRefSet *pcrs = GPOS_NEW(pmp) CColRefSet(pmp);
DrgPcr *pdrgpcr = GPOS_NEW(pmp) DrgPcr(pmp);
COptCtxt *poptctxt = COptCtxt::PoctxtFromTLS();
CColumnFactory *pcf = poptctxt->Pcf();
GPOS_ASSERT(NULL != pcf);
const ULONG ulLen = pdrgpulQueryOutputColRefId->UlLength();
for (ULONG ul = 0; ul < ulLen; ul++)
{
ULONG *pul = (*pdrgpulQueryOutputColRefId)[ul];
GPOS_ASSERT(NULL != pul);
CColRef *pcr = pcf->PcrLookup(*pul);
GPOS_ASSERT(NULL != pcr);
pcrs->Include(pcr);
pdrgpcr->Append(pcr);
}
COrderSpec *pos = NULL;
CExpression *pexprResult = pexpr;
COperator *popTop = PopTop(pexpr);
if (COperator::EopLogicalLimit == popTop->Eopid())
{
// top level operator is a limit, copy order spec to query context
pos = CLogicalLimit::PopConvert(popTop)->Pos();
pos->AddRef();
}
else
{
// no order required
pos = GPOS_NEW(pmp) COrderSpec(pmp);
}
CDistributionSpec *pds = NULL;
BOOL fDML = CUtils::FLogicalDML(pexpr->Pop());
poptctxt->MarkDMLQuery(fDML);
if (fDML)
{
pds = GPOS_NEW(pmp) CDistributionSpecAny(COperator::EopSentinel);
}
else
{
pds = GPOS_NEW(pmp) CDistributionSpecSingleton(CDistributionSpecSingleton::EstMaster);
}
CRewindabilitySpec *prs = GPOS_NEW(pmp) CRewindabilitySpec(CRewindabilitySpec::ErtNone /*ert*/);
CEnfdOrder *peo = GPOS_NEW(pmp) CEnfdOrder(pos, CEnfdOrder::EomSatisfy);
// we require satisfy matching on distribution since final query results must be sent to master
CEnfdDistribution *ped = GPOS_NEW(pmp) CEnfdDistribution(pds, CEnfdDistribution::EdmSatisfy);
CEnfdRewindability *per = GPOS_NEW(pmp) CEnfdRewindability(prs, CEnfdRewindability::ErmSatisfy);
CCTEReq *pcter = poptctxt->Pcteinfo()->PcterProducers(pmp);
CReqdPropPlan *prpp = GPOS_NEW(pmp) CReqdPropPlan(pcrs, peo, ped, per, pcter);
pdrgpmdname->AddRef();
return GPOS_NEW(pmp) CQueryContext(pmp, pexprResult, prpp, pdrgpcr, pdrgpmdname, fDeriveStats);
}
//---------------------------------------------------------------------------
// @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:
// CColRefSetIterTest::EresUnittest_Basics
//
// @doc:
// Testing ctors/dtor; and pcr decoding;
// Other functionality already tested in vanilla CBitSetIter;
//
//---------------------------------------------------------------------------
GPOS_RESULT
CColRefSetIterTest::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());
mda.RegisterProvider(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();
CColRefSet *pcrs = GPOS_NEW(pmp) CColRefSet(pmp);
CWStringConst strName(GPOS_WSZ_LIT("Test Column"));
CName name(&strName);
// create a int4 datum
const IMDTypeInt4 *pmdtypeint4 = mda.PtMDType<IMDTypeInt4>();
ULONG ulCols = 10;
for(ULONG i = 0; i < ulCols; i++)
{
CColRef *pcr = pcf->PcrCreate(pmdtypeint4, name);
pcrs->Include(pcr);
GPOS_ASSERT(pcrs->FMember(pcr));
}
GPOS_ASSERT(pcrs->CElements() == ulCols);
ULONG ulCount = 0;
CColRefSetIter crsi(*pcrs);
while(crsi.FAdvance())
{
GPOS_ASSERT((BOOL)crsi);
CColRef *pcr = crsi.Pcr();
GPOS_ASSERT(pcr->Name().FEquals(name));
// to avoid unused variable warnings
(void) pcr->UlId();
ulCount++;
}
GPOS_ASSERT(ulCols == ulCount);
GPOS_ASSERT(!((BOOL)crsi));
pcrs->Release();
return GPOS_OK;
}
