//---------------------------------------------------------------------------
// @function:
// CStatsPredUtils::PdrgpstatsjoinExtract
//
// @doc:
// Helper function to extract array of statistics join filter
// from an array of join predicates
//
//---------------------------------------------------------------------------
DrgPstatsjoin *
CStatsPredUtils::PdrgpstatsjoinExtract
(
IMemoryPool *pmp,
CExpression *pexprScalar,
DrgPcrs *pdrgpcrsOutput, // array of output columns of join's relational inputs
CColRefSet *pcrsOuterRefs,
CStatsPred **ppstatspredUnsupported
)
{
GPOS_ASSERT(NULL != pexprScalar);
GPOS_ASSERT(NULL != pdrgpcrsOutput);
DrgPstatsjoin *pdrgpstatsjoin = GPOS_NEW(pmp) DrgPstatsjoin(pmp);
DrgPexpr *pdrgpexprUnsupported = GPOS_NEW(pmp) DrgPexpr(pmp);
// extract all the conjuncts
DrgPexpr *pdrgpexprConjuncts = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprScalar);
const ULONG ulSize = pdrgpexprConjuncts->UlLength();
for (ULONG ul = 0; ul < ulSize; ul++)
{
CExpression *pexprPred = (*pdrgpexprConjuncts) [ul];
CStatisticsJoin *pstatsjoin = PstatsjoinExtract
(
pmp,
pexprPred,
pdrgpcrsOutput,
pcrsOuterRefs,
pdrgpexprUnsupported
);
if (NULL != pstatsjoin)
{
pdrgpstatsjoin->Append(pstatsjoin);
}
}
const ULONG ulUnsupported = pdrgpexprUnsupported->UlLength();
if (1 == ulUnsupported)
{
*ppstatspredUnsupported = CStatsPredUtils::PstatspredExtract(pmp, (*pdrgpexprUnsupported)[0], pcrsOuterRefs);
}
else if (1 < ulUnsupported)
{
pdrgpexprUnsupported->AddRef();
CExpression *pexprConj = CPredicateUtils::PexprConjDisj(pmp, pdrgpexprUnsupported, true /* fConjunction */);
*ppstatspredUnsupported = CStatsPredUtils::PstatspredExtract(pmp, pexprConj, pcrsOuterRefs);
pexprConj->Release();
}
// clean up
pdrgpexprUnsupported->Release();
pdrgpexprConjuncts->Release();
return pdrgpstatsjoin;
}
//---------------------------------------------------------------------------
// @function:
// CNormalizer::SplitConjunctForSeqPrj
//
// @doc:
// Split the given conjunct into pushable and unpushable predicates
// for a sequence project expression
//
//---------------------------------------------------------------------------
void
CNormalizer::SplitConjunctForSeqPrj
(
IMemoryPool *pmp,
CExpression *pexprSeqPrj,
CExpression *pexprConj,
DrgPexpr **ppdrgpexprPushable,
DrgPexpr **ppdrgpexprUnpushable
)
{
GPOS_ASSERT(NULL != pexprSeqPrj);
GPOS_ASSERT(NULL != pexprConj);
GPOS_ASSERT(NULL != ppdrgpexprPushable);
GPOS_ASSERT(NULL != ppdrgpexprUnpushable);
*ppdrgpexprPushable = GPOS_NEW(pmp) DrgPexpr(pmp);
*ppdrgpexprUnpushable = GPOS_NEW(pmp) DrgPexpr(pmp);
DrgPexpr *pdrgpexprPreds = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprConj);
const ULONG ulPreds = pdrgpexprPreds->UlLength();
for (ULONG ul = 0; ul < ulPreds; ul++)
{
CExpression *pexprPred = (*pdrgpexprPreds)[ul];
pexprPred->AddRef();
if (FPushableThruSeqPrjChild(pexprSeqPrj, pexprPred))
{
(*ppdrgpexprPushable)->Append(pexprPred);
}
else
{
(*ppdrgpexprUnpushable)->Append(pexprPred);
}
}
pdrgpexprPreds->Release();
}
//---------------------------------------------------------------------------
// @function:
// CNormalizer::SplitConjunct
//
// @doc:
// Split the given conjunct into pushable and unpushable predicates
//
//
//---------------------------------------------------------------------------
void
CNormalizer::SplitConjunct
(
IMemoryPool *pmp,
CExpression *pexpr,
CExpression *pexprConj,
DrgPexpr **ppdrgpexprPushable,
DrgPexpr **ppdrgpexprUnpushable
)
{
GPOS_ASSERT(pexpr->Pop()->FLogical());
GPOS_ASSERT(pexprConj->Pop()->FScalar());
GPOS_ASSERT(NULL != ppdrgpexprPushable);
GPOS_ASSERT(NULL != ppdrgpexprUnpushable);
// collect pushable predicates from given conjunct
*ppdrgpexprPushable = GPOS_NEW(pmp) DrgPexpr(pmp);
*ppdrgpexprUnpushable = GPOS_NEW(pmp) DrgPexpr(pmp);
DrgPexpr *pdrgpexprConjuncts = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprConj);
const ULONG ulSize = pdrgpexprConjuncts->UlLength();
for (ULONG ul = 0; ul < ulSize; ul++)
{
CExpression *pexprScalar = (*pdrgpexprConjuncts)[ul];
pexprScalar->AddRef();
if (FPushable(pexpr, pexprScalar))
{
(*ppdrgpexprPushable)->Append(pexprScalar);
}
else
{
(*ppdrgpexprUnpushable)->Append(pexprScalar);
}
}
pdrgpexprConjuncts->Release();
}
//---------------------------------------------------------------------------
// @function:
// CNormalizer::PushThruUnaryWithScalarChild
//
// @doc:
// Push a conjunct through a unary operator with scalar child
//
//---------------------------------------------------------------------------
void
CNormalizer::PushThruUnaryWithScalarChild
(
IMemoryPool *pmp,
CExpression *pexprLogical,
CExpression *pexprConj,
CExpression **ppexprResult
)
{
GPOS_ASSERT(NULL != pexprLogical);
GPOS_ASSERT(2 == pexprLogical->UlArity());
GPOS_ASSERT(NULL != pexprConj);
GPOS_ASSERT(NULL != ppexprResult);
// get logical and scalar children
CExpression *pexprLogicalChild = (*pexprLogical)[0];
CExpression *pexprScalarChild = (*pexprLogical)[1];
// push conjuncts through the logical child
CExpression *pexprNewLogicalChild = NULL;
DrgPexpr *pdrgpexprUnpushable = NULL;
// break scalar expression to conjuncts
DrgPexpr *pdrgpexprConjuncts = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprConj);
PushThru(pmp, pexprLogicalChild, pdrgpexprConjuncts, &pexprNewLogicalChild, &pdrgpexprUnpushable);
pdrgpexprConjuncts->Release();
// create a new logical expression based on recursion results
COperator *pop = pexprLogical->Pop();
pop->AddRef();
pexprScalarChild->AddRef();
CExpression *pexprNewLogical = GPOS_NEW(pmp) CExpression(pmp, pop, pexprNewLogicalChild, pexprScalarChild);
*ppexprResult = PexprSelect(pmp, pexprNewLogical, pdrgpexprUnpushable);
}
//---------------------------------------------------------------------------
// @function:
// COptimizer::PrintQuery
//
// @doc:
// Helper function to print query expression
//
//---------------------------------------------------------------------------
void
COptimizer::PrintQuery
(
IMemoryPool *pmp,
CExpression *pexprTranslated,
CQueryContext *pqc
)
{
CAutoTrace at(pmp);
at.Os() << std::endl << "Algebrized query: " << std::endl << *pexprTranslated;
DrgPexpr *pdrgpexpr = COptCtxt::PoctxtFromTLS()->Pcteinfo()->PdrgPexpr(pmp);
const ULONG ulCTEs = pdrgpexpr->UlLength();
if (0 < ulCTEs)
{
at.Os() << std::endl << "Common Table Expressions: ";
for (ULONG ul = 0; ul < ulCTEs; ul++)
{
at.Os() << std::endl << *(*pdrgpexpr)[ul];
}
}
pdrgpexpr->Release();
CExpression *pexprPreprocessed = pqc->Pexpr();
(void) pexprPreprocessed->PdpDerive();
at.Os() << std::endl << "Algebrized preprocessed query: " << std::endl << *pexprPreprocessed;
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalUnionAll::PdshashedPassThru
//
// @doc:
// Compute required hashed distribution of the n-th child
//
//---------------------------------------------------------------------------
CDistributionSpecHashed *
CPhysicalUnionAll::PdshashedPassThru
(
IMemoryPool *pmp,
CDistributionSpecHashed *pdshashedRequired,
ULONG ulChildIndex
)
const
{
DrgPexpr *pdrgpexprRequired = pdshashedRequired->Pdrgpexpr();
DrgPcr *pdrgpcrChild = (*m_pdrgpdrgpcrInput)[ulChildIndex];
const ULONG ulExprs = pdrgpexprRequired->UlLength();
const ULONG ulOutputCols = m_pdrgpcrOutput->UlLength();
DrgPexpr *pdrgpexprChildRequired = GPOS_NEW(pmp) DrgPexpr(pmp);
for (ULONG ulExpr = 0; ulExpr < ulExprs; ulExpr++)
{
CExpression *pexpr = (*pdrgpexprRequired)[ulExpr];
if (COperator::EopScalarIdent != pexpr->Pop()->Eopid())
{
// skip expressions that are not in form of scalar identifiers
continue;
}
const CColRef *pcrHashed = CScalarIdent::PopConvert(pexpr->Pop())->Pcr();
const IMDType *pmdtype = pcrHashed->Pmdtype();
if (!pmdtype->FHashable())
{
// skip non-hashable columns
continue;
}
for (ULONG ulCol = 0; ulCol < ulOutputCols; ulCol++)
{
const CColRef *pcrOutput = (*m_pdrgpcrOutput)[ulCol];
if (pcrOutput == pcrHashed)
{
const CColRef *pcrInput = (*pdrgpcrChild)[ulCol];
pdrgpexprChildRequired->Append(CUtils::PexprScalarIdent(pmp, pcrInput));
}
}
}
if (0 < pdrgpexprChildRequired->UlLength())
{
return GPOS_NEW(pmp) CDistributionSpecHashed(pdrgpexprChildRequired, true /* fNullsCollocated */);
}
// failed to create a matching hashed distribution
pdrgpexprChildRequired->Release();
if (NULL != pdshashedRequired->PdshashedEquiv())
{
// try again with equivalent distribution
return PdshashedPassThru(pmp, pdshashedRequired->PdshashedEquiv(), ulChildIndex);
}
// failed to create hashed distribution
return NULL;
}
//---------------------------------------------------------------------------
// @function:
// CNormalizer::PushThruSelect
//
// @doc:
// Push a conjunct through a select
//
//---------------------------------------------------------------------------
void
CNormalizer::PushThruSelect
(
IMemoryPool *pmp,
CExpression *pexprSelect,
CExpression *pexprConj,
CExpression **ppexprResult
)
{
GPOS_ASSERT(NULL != pexprConj);
GPOS_ASSERT(NULL != ppexprResult);
CExpression *pexprLogicalChild = (*pexprSelect)[0];
CExpression *pexprScalarChild = (*pexprSelect)[1];
CExpression *pexprPred = CPredicateUtils::PexprConjunction(pmp, pexprScalarChild, pexprConj);
if (CUtils::FScalarConstTrue(pexprPred))
{
pexprPred->Release();
*ppexprResult = PexprNormalize(pmp, pexprLogicalChild);
return;
}
COperator::EOperatorId eopid = pexprLogicalChild->Pop()->Eopid();
if (COperator::EopLogicalLeftOuterJoin == eopid)
{
CExpression *pexprSimplified = NULL;
if (FSimplifySelectOnOuterJoin(pmp, pexprLogicalChild, pexprPred, &pexprSimplified))
{
// simplification succeeded, normalize resulting expression
*ppexprResult = PexprNormalize(pmp, pexprSimplified);
pexprPred->Release();
pexprSimplified->Release();
return;
}
}
if (FPushThruOuterChild(pexprLogicalChild))
{
PushThruOuterChild(pmp, pexprLogicalChild, pexprPred, ppexprResult);
}
else
{
// logical child may not pass all predicates through, we need to collect
// unpushable predicates, if any, into a top Select node
DrgPexpr *pdrgpexprConjuncts = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprPred);
DrgPexpr *pdrgpexprRemaining = NULL;
CExpression *pexpr = NULL;
PushThru(pmp, pexprLogicalChild, pdrgpexprConjuncts, &pexpr, &pdrgpexprRemaining);
*ppexprResult = PexprSelect(pmp, pexpr, pdrgpexprRemaining);
pdrgpexprConjuncts->Release();
}
pexprPred->Release();
}
//---------------------------------------------------------------------------
// @function:
// CBinding::PexprExtract
//
// @doc:
// Extract a binding according to a given pattern;
// Keep root node fixed;
//
//---------------------------------------------------------------------------
CExpression *
CBinding::PexprExtract
(
IMemoryPool *pmp,
CGroupExpression *pgexpr,
CExpression *pexprPattern,
CExpression *pexprLast
)
{
GPOS_CHECK_ABORT;
if (!pexprPattern->FMatchPattern(pgexpr))
{
// shallow matching fails
return NULL;
}
// the previously extracted pattern must have the same root
GPOS_ASSERT_IMP(NULL != pexprLast, pexprLast->Pgexpr() == pgexpr);
COperator *popPattern = pexprPattern->Pop();
if (popPattern->FPattern() && CPattern::PopConvert(popPattern)->FLeaf())
{
// return immediately; no deep extraction for leaf patterns
pgexpr->Pop()->AddRef();
return GPOS_NEW(pmp) CExpression(pmp, pgexpr->Pop(), pgexpr);
}
DrgPexpr *pdrgpexpr = NULL;
ULONG ulArity = pgexpr->UlArity();
if (0 == ulArity && NULL != pexprLast)
{
// no more bindings
return NULL;
}
else
{
// attempt binding to children
pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp);
if (!FExtractChildren(pmp, pgexpr, pexprPattern, pexprLast, pdrgpexpr))
{
pdrgpexpr->Release();
return NULL;
}
}
CExpression *pexpr = PexprFinalize(pmp, pgexpr, pdrgpexpr);
GPOS_ASSERT(NULL != pexpr);
return pexpr;
}
//---------------------------------------------------------------------------
// @function:
// CStatsPredUtils::FConjunction
//
// @doc:
// Is the condition a conjunctive predicate
//---------------------------------------------------------------------------
BOOL
CStatsPredUtils::FConjunction
(
IMemoryPool *pmp,
CExpression *pexprPred
)
{
GPOS_ASSERT(NULL != pexprPred);
DrgPexpr *pdrgpexprConjuncts = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprPred);
const ULONG ulLen = pdrgpexprConjuncts->UlLength();
pdrgpexprConjuncts->Release();
return (1 < ulLen);
}
//---------------------------------------------------------------------------
// @function:
// CLogicalInnerJoin::FFewerConj
//
// @doc:
// Compare two innerJoin group expressions, test whether the first one
// has less join predicates than the second one. This is used to
// prioritize innerJoin with less predicates for stats derivation
//
//---------------------------------------------------------------------------
BOOL
CLogicalInnerJoin::FFewerConj
(
IMemoryPool *pmp,
CGroupExpression *pgexprFst,
CGroupExpression *pgexprSnd
)
{
if (NULL == pgexprFst || NULL == pgexprSnd)
{
return false;
}
if (COperator::EopLogicalInnerJoin != pgexprFst->Pop()->Eopid() ||
COperator::EopLogicalInnerJoin != pgexprSnd->Pop()->Eopid())
{
return false;
}
// third child must be the group for join conditions
CGroup *pgroupScalarFst = (*pgexprFst)[2];
CGroup *pgroupScalarSnd = (*pgexprSnd)[2];
GPOS_ASSERT(pgroupScalarFst->FScalar());
GPOS_ASSERT(pgroupScalarSnd->FScalar());
DrgPexpr *pdrgpexprConjFst = CPredicateUtils::PdrgpexprConjuncts(pmp, pgroupScalarFst->PexprScalar());
DrgPexpr *pdrgpexprConjSnd = CPredicateUtils::PdrgpexprConjuncts(pmp, pgroupScalarSnd->PexprScalar());
ULONG ulConjFst = pdrgpexprConjFst->UlLength();
ULONG ulConjSnd = pdrgpexprConjSnd->UlLength();
pdrgpexprConjFst->Release();
pdrgpexprConjSnd->Release();
return ulConjFst < ulConjSnd;
}
//---------------------------------------------------------------------------
// @function:
// CStatsPredUtils::PstatspredConj
//
// @doc:
// Create conjunctive statistics filter composed of the extracted
// components of the conjunction
//---------------------------------------------------------------------------
CStatsPred *
CStatsPredUtils::PstatspredConj
(
IMemoryPool *pmp,
CExpression *pexprScalar,
CColRefSet *pcrsOuterRefs
)
{
GPOS_ASSERT(NULL != pexprScalar);
DrgPexpr *pdrgpexprConjuncts = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprScalar);
const ULONG ulLen = pdrgpexprConjuncts->UlLength();
DrgPstatspred *pdrgpstatspred = GPOS_NEW(pmp) DrgPstatspred(pmp);
for (ULONG ul = 0; ul < ulLen; ul++)
{
CExpression *pexprPred = (*pdrgpexprConjuncts)[ul];
CColRefSet *pcrsUsed = CDrvdPropScalar::Pdpscalar(pexprPred->PdpDerive())->PcrsUsed();
if (NULL != pcrsOuterRefs && pcrsOuterRefs->FSubset(pcrsUsed))
{
// skip predicate with outer references
continue;
}
if (CPredicateUtils::FOr(pexprPred))
{
CStatsPred *pstatspredDisj = PstatspredDisj(pmp, pexprPred, pcrsOuterRefs);
if (NULL != pstatspredDisj)
{
pdrgpstatspred->Append(pstatspredDisj);
}
}
else
{
AddSupportedStatsFilters(pmp, pdrgpstatspred, pexprPred, pcrsOuterRefs);
}
}
pdrgpexprConjuncts->Release();
if (0 < pdrgpstatspred->UlLength())
{
return GPOS_NEW(pmp) CStatsPredConj(pdrgpstatspred);
}
pdrgpstatspred->Release();
return NULL;
}
//---------------------------------------------------------------------------
// @function:
// CNormalizer::PushThruSeqPrj
//
// @doc:
// Push a conjunct through a sequence project expression
//
//---------------------------------------------------------------------------
void
CNormalizer::PushThruSeqPrj
(
IMemoryPool *pmp,
CExpression *pexprSeqPrj,
CExpression *pexprConj,
CExpression **ppexprResult
)
{
GPOS_ASSERT(NULL != pexprSeqPrj);
GPOS_ASSERT(CLogical::EopLogicalSequenceProject == pexprSeqPrj->Pop()->Eopid());
GPOS_ASSERT(NULL != pexprConj);
GPOS_ASSERT(NULL != ppexprResult);
// get logical and scalar children
CExpression *pexprLogicalChild = (*pexprSeqPrj)[0];
CExpression *pexprScalarChild = (*pexprSeqPrj)[1];
// break scalar expression to pushable and unpushable conjuncts
DrgPexpr *pdrgpexprPushable = NULL;
DrgPexpr *pdrgpexprUnpushable = NULL;
SplitConjunctForSeqPrj(pmp, pexprSeqPrj, pexprConj, &pdrgpexprPushable, &pdrgpexprUnpushable);
CExpression *pexprNewLogicalChild = NULL;
if (0 < pdrgpexprPushable->UlLength())
{
CExpression *pexprPushableConj = CPredicateUtils::PexprConjunction(pmp, pdrgpexprPushable);
PushThru(pmp, pexprLogicalChild, pexprPushableConj, &pexprNewLogicalChild);
pexprPushableConj->Release();
}
else
{
// no pushable predicates on top of sequence project,
// we still need to process child recursively to push-down child's own predicates
pdrgpexprPushable->Release();
pexprNewLogicalChild = PexprNormalize(pmp, pexprLogicalChild);
}
// create a new logical expression based on recursion results
COperator *pop = pexprSeqPrj->Pop();
pop->AddRef();
pexprScalarChild->AddRef();
CExpression *pexprNewLogical = GPOS_NEW(pmp) CExpression(pmp, pop, pexprNewLogicalChild, pexprScalarChild);
// create a select node for remaining predicates, if any
*ppexprResult = PexprSelect(pmp, pexprNewLogical, pdrgpexprUnpushable);
}
//---------------------------------------------------------------------------
// @function:
// CStatsPredUtils::PstatspredDisj
//
// @doc:
// Create disjunctive statistics filter composed of the extracted
// components of the disjunction
//---------------------------------------------------------------------------
CStatsPred *
CStatsPredUtils::PstatspredDisj
(
IMemoryPool *pmp,
CExpression *pexprPred,
CColRefSet *pcrsOuterRefs
)
{
GPOS_ASSERT(NULL != pexprPred);
GPOS_ASSERT(CPredicateUtils::FOr(pexprPred));
DrgPstatspred *pdrgpstatspredDisjChild = GPOS_NEW(pmp) DrgPstatspred(pmp);
// remove duplicate components of the OR tree
CExpression *pexprNew = CExpressionUtils::PexprDedupChildren(pmp, pexprPred);
// extract the components of the OR tree
DrgPexpr *pdrgpexpr = CPredicateUtils::PdrgpexprDisjuncts(pmp, pexprNew);
const ULONG ulLen = pdrgpexpr->UlLength();
for (ULONG ul = 0; ul < ulLen; ul++)
{
CExpression *pexpr = (*pdrgpexpr)[ul];
CColRefSet *pcrsUsed = CDrvdPropScalar::Pdpscalar(pexpr->PdpDerive())->PcrsUsed();
if (NULL != pcrsOuterRefs && pcrsOuterRefs->FSubset(pcrsUsed))
{
// skip predicate with outer references
continue;
}
AddSupportedStatsFilters(pmp, pdrgpstatspredDisjChild, pexpr, pcrsOuterRefs);
}
// clean up
pexprNew->Release();
pdrgpexpr->Release();
if (0 < pdrgpstatspredDisjChild->UlLength())
{
return GPOS_NEW(pmp) CStatsPredDisj(pdrgpstatspredDisjChild);
}
pdrgpstatspredDisjChild->Release();
return NULL;
}
//---------------------------------------------------------------------------
// @function:
// CDistributionSpecHashed::PdshashedExcludeColumns
//
// @doc:
// Return a copy of the distribution spec after excluding the given
// columns, return NULL if all distribution expressions are excluded
//
//---------------------------------------------------------------------------
CDistributionSpecHashed *
CDistributionSpecHashed::PdshashedExcludeColumns
(
IMemoryPool *pmp,
CColRefSet *pcrs
)
{
GPOS_ASSERT(NULL != pcrs);
DrgPexpr *pdrgpexprNew = GPOS_NEW(pmp) DrgPexpr(pmp);
const ULONG ulExprs = m_pdrgpexpr->UlLength();
for (ULONG ul = 0; ul < ulExprs; ul++)
{
CExpression *pexpr = (*m_pdrgpexpr)[ul];
COperator *pop = pexpr->Pop();
if (COperator::EopScalarIdent == pop->Eopid())
{
// we only care here about column identifiers,
// any more complicated expressions are copied to output
const CColRef *pcr = CScalarIdent::PopConvert(pop)->Pcr();
if (pcrs->FMember(pcr))
{
continue;
}
}
pexpr->AddRef();
pdrgpexprNew->Append(pexpr);
}
if (0 == pdrgpexprNew->UlLength())
{
pdrgpexprNew->Release();
return NULL;
}
return GPOS_NEW(pmp) CDistributionSpecHashed(pdrgpexprNew, m_fNullsColocated);
}
//---------------------------------------------------------------------------
// @function:
// CCNFConverter::PexprOr2CNF
//
// @doc:
// Convert an OR tree into CNF
//
//---------------------------------------------------------------------------
CExpression *
CCNFConverter::PexprOr2CNF
(
IMemoryPool *pmp,
CExpression *pexpr
)
{
GPOS_ASSERT(NULL != pmp);
GPOS_ASSERT(NULL != pexpr);
DrgPexpr *pdrgpexpr = PdrgpexprConvertChildren(pmp, pexpr);
// build array of arrays each representing terms in a disjunct
DrgPdrgPexpr *pdrgpdrgpexprDisjuncts = Pdrgpdrgpexpr(pmp, pdrgpexpr);
pdrgpexpr->Release();
// compute conjuncts by distributing AND over OR
DrgPexpr *pdrgpexprChildren = GPOS_NEW(pmp) DrgPexpr(pmp);
Expand(pmp, pdrgpdrgpexprDisjuncts, pdrgpexprChildren, GPOS_NEW(pmp) DrgPexpr(pmp), 0 /*ulCurrent*/);
pdrgpdrgpexprDisjuncts->Release();
return CPredicateUtils::PexprConjunction(pmp, pdrgpexprChildren);
}
//---------------------------------------------------------------------------
// @function:
// CPredicateUtilsTest::EresUnittest_Conjunctions
//
// @doc:
// Test extraction and construction of conjuncts
//
//---------------------------------------------------------------------------
GPOS_RESULT
CPredicateUtilsTest::EresUnittest_Conjunctions()
{
CAutoMemoryPool amp;
IMemoryPool *pmp = amp.Pmp();
// setup a file-based provider
CMDProviderMemory *pmdp = CTestUtils::m_pmdpf;
pmdp->AddRef();
CMDAccessor mda(pmp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp);
// install opt context in TLS
CAutoOptCtxt aoc
(
pmp,
&mda,
NULL, /* pceeval */
CTestUtils::Pcm(pmp)
);
// build conjunction
DrgPexpr *pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp);
const ULONG ulConjs = 3;
for (ULONG ul = 0; ul < ulConjs; ul++)
{
pdrgpexpr->Append(CUtils::PexprScalarConstBool(pmp, true /*fValue*/));
}
CExpression *pexprConjunction = CUtils::PexprScalarBoolOp(pmp, CScalarBoolOp::EboolopAnd, pdrgpexpr);
// break into conjuncts
DrgPexpr *pdrgpexprExtract = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprConjunction);
GPOS_ASSERT(pdrgpexprExtract->UlLength() == ulConjs);
// collapse into single conjunct
CExpression *pexpr = CPredicateUtils::PexprConjunction(pmp, pdrgpexprExtract);
GPOS_ASSERT(NULL != pexpr);
GPOS_ASSERT(CUtils::FScalarConstTrue(pexpr));
pexpr->Release();
// collapse empty input array to conjunct
CExpression *pexprSingleton = CPredicateUtils::PexprConjunction(pmp, NULL /*pdrgpexpr*/);
GPOS_ASSERT(NULL != pexprSingleton);
pexprSingleton->Release();
pexprConjunction->Release();
// conjunction on scalar comparisons
CExpression *pexprGet = CTestUtils::PexprLogicalGet(pmp);
CColRefSet *pcrs = CDrvdPropRelational::Pdprel(pexprGet->PdpDerive())->PcrsOutput();
CColRef *pcr1 = pcrs->PcrAny();
CColRef *pcr2 = pcrs->PcrFirst();
CExpression *pexprCmp1 = CUtils::PexprScalarCmp(pmp, pcr1, pcr2, IMDType::EcmptEq);
CExpression *pexprCmp2 = CUtils::PexprScalarCmp(pmp, pcr1, CUtils::PexprScalarConstInt4(pmp, 1 /*iVal*/), IMDType::EcmptEq);
CExpression *pexprConj = CPredicateUtils::PexprConjunction(pmp, pexprCmp1, pexprCmp2);
pdrgpexprExtract = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprConj);
GPOS_ASSERT(2 == pdrgpexprExtract->UlLength());
pdrgpexprExtract->Release();
pexprCmp1->Release();
pexprCmp2->Release();
pexprConj->Release();
pexprGet->Release();
return GPOS_OK;
}
void
CXformJoinAssociativity::Transform
(
CXformContext *pxfctxt,
CXformResult *pxfres,
CExpression *pexpr
)
const
{
GPOS_ASSERT(NULL != pxfctxt);
GPOS_ASSERT(FPromising(pxfctxt->Pmp(), this, pexpr));
GPOS_ASSERT(FCheckPattern(pexpr));
IMemoryPool *pmp = pxfctxt->Pmp();
// create new predicates
DrgPexpr *pdrgpexprLower = GPOS_NEW(pmp) DrgPexpr(pmp);
DrgPexpr *pdrgpexprUpper = GPOS_NEW(pmp) DrgPexpr(pmp);
CreatePredicates(pmp, pexpr, pdrgpexprLower, pdrgpexprUpper);
GPOS_ASSERT(pdrgpexprLower->UlLength() > 0);
// cross join contains CScalarConst(1) as the join condition. if the
// input expression is as below with cross join at top level between
// CLogicalInnerJoin and CLogicalGet "t3"
// +--CLogicalInnerJoin
// |--CLogicalInnerJoin
// | |--CLogicalGet "t1"
// | |--CLogicalGet "t2"
// | +--CScalarCmp (=)
// | |--CScalarIdent "a" (0)
// | +--CScalarIdent "b" (9)
// |--CLogicalGet "t3"
// +--CScalarConst (1)
// for the above expression (lower) predicate generated for the cross join
// between t1 and t3 will be: CScalarConst (1) In *only* such cases, donot
// generate such alternative with the lower join as cross join example:
// +--CLogicalInnerJoin
// |--CLogicalInnerJoin
// | |--CLogicalGet "t1"
// | |--CLogicalGet "t3"
// | +--CScalarConst (1)
// |--CLogicalGet "t2"
// +--CScalarCmp (=)
// |--CScalarIdent "a" (0)
// +--CScalarIdent "b" (9)
// NOTE that we want to be careful to check that input lower join wasn't a
// cross join to begin with, because we want to build a join in this case even
// though a new cross join will be created.
// check if the input lower join expression is a cross join
BOOL fInputLeftIsCrossJoin = CUtils::FCrossJoin((*pexpr)[0]);
// check if the output lower join would result in a cross join
BOOL fOutputLeftIsCrossJoin = (1 == pdrgpexprLower->UlLength() &&
CUtils::FScalarConstTrue((*pdrgpexprLower)[0]));
// build a join only if it does not result in a cross join
// unless the input itself was a cross join (see earlier comments)
if (!fOutputLeftIsCrossJoin || fInputLeftIsCrossJoin)
{
// bind operators
CExpression *pexprLeft = (*pexpr)[0];
CExpression *pexprLeftLeft = (*pexprLeft)[0];
CExpression *pexprLeftRight = (*pexprLeft)[1];
CExpression *pexprRight = (*pexpr)[1];
// add-ref all components for re-use
pexprLeftLeft->AddRef();
pexprRight->AddRef();
pexprLeftRight->AddRef();
// build new joins
CExpression *pexprBottomJoin = CUtils::PexprLogicalJoin<CLogicalInnerJoin>
(
pmp,
pexprLeftLeft,
pexprRight,
CPredicateUtils::PexprConjunction(pmp, pdrgpexprLower)
);
CExpression *pexprResult = CUtils::PexprLogicalJoin<CLogicalInnerJoin>
(
pmp,
pexprBottomJoin,
pexprLeftRight,
CPredicateUtils::PexprConjunction(pmp, pdrgpexprUpper)
);
// add alternative to transformation result
pxfres->Add(pexprResult);
}
else
{
pdrgpexprLower->Release();
pdrgpexprUpper->Release();
}
}
//---------------------------------------------------------------------------
// @function:
// CDecorrelator::FProcessJoin
//
// @doc:
// Decorrelate a join expression;
//
//---------------------------------------------------------------------------
BOOL
CDecorrelator::FProcessJoin
(
IMemoryPool *pmp,
CExpression *pexpr,
BOOL fEqualityOnly,
CExpression **ppexprDecorrelated,
DrgPexpr *pdrgpexprCorrelations
)
{
GPOS_ASSERT(CUtils::FLogicalJoin(pexpr->Pop()) || CUtils::FApply(pexpr->Pop()));
ULONG ulArity = pexpr->UlArity();
DrgPexpr *pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp, ulArity);
CColRefSet *pcrsOutput = GPOS_NEW(pmp) CColRefSet(pmp);
// decorrelate all relational children
for (ULONG ul = 0; ul < ulArity - 1; ul++)
{
CExpression *pexprInput = NULL;
if (FProcess(pmp, (*pexpr)[ul], fEqualityOnly, &pexprInput, pdrgpexprCorrelations))
{
pdrgpexpr->Append(pexprInput);
pcrsOutput->Union(CDrvdPropRelational::Pdprel(pexprInput->PdpDerive())->PcrsOutput());
}
else
{
pdrgpexpr->Release();
pcrsOutput->Release();
return false;
}
}
// check for valid semi join correlations
if (!FPullableCorrelations(pmp, pexpr, pdrgpexpr, pdrgpexprCorrelations))
{
pdrgpexpr->Release();
pcrsOutput->Release();
return false;
}
// decorrelate predicate and build new join operator
CExpression *pexprPredicate = NULL;
BOOL fSuccess = FProcessPredicate(pmp, pexpr, (*pexpr)[ulArity - 1], fEqualityOnly, pcrsOutput, &pexprPredicate, pdrgpexprCorrelations);
pcrsOutput->Release();
if (fSuccess)
{
// in case entire predicate is being deferred, plug in a 'true'
if (NULL == pexprPredicate)
{
pexprPredicate = CUtils::PexprScalarConstBool(pmp, true /*fVal*/);
}
pdrgpexpr->Append(pexprPredicate);
COperator *pop = pexpr->Pop();
pop->AddRef();
*ppexprDecorrelated = GPOS_NEW(pmp) CExpression(pmp, pop, pdrgpexpr);
}
else
{
pdrgpexpr->Release();
CRefCount::SafeRelease(pexprPredicate);
}
return fSuccess;
}
//---------------------------------------------------------------------------
// @function:
// CPartitionPropagationSpec::SplitPartPredicates
//
// @doc:
// Split the partition elimination predicates over the various levels
// as well as the residual predicate and add them to the appropriate
// hashmaps. These are to be used when creating the partition selector
//
//---------------------------------------------------------------------------
void
CPartitionPropagationSpec::SplitPartPredicates
(
IMemoryPool *pmp,
CExpression *pexprScalar,
DrgDrgPcr *pdrgpdrgpcrKeys,
HMUlExpr *phmulexprEqFilter, // output
HMUlExpr *phmulexprFilter, // output
CExpression **ppexprResidual // output
)
{
GPOS_ASSERT(NULL != pexprScalar);
GPOS_ASSERT(NULL != pdrgpdrgpcrKeys);
GPOS_ASSERT(NULL != phmulexprEqFilter);
GPOS_ASSERT(NULL != phmulexprFilter);
GPOS_ASSERT(NULL != ppexprResidual);
GPOS_ASSERT(NULL == *ppexprResidual);
DrgPexpr *pdrgpexprConjuncts = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprScalar);
CBitSet *pbsUsed = GPOS_NEW(pmp) CBitSet(pmp);
CColRefSet *pcrsKeys = PcrsKeys(pmp, pdrgpdrgpcrKeys);
const ULONG ulLevels = pdrgpdrgpcrKeys->UlLength();
for (ULONG ul = 0; ul < ulLevels; ul++)
{
CColRef *pcr = CUtils::PcrExtractPartKey(pdrgpdrgpcrKeys, ul);
// find conjuncts for this key and mark their positions
DrgPexpr *pdrgpexprKey = PdrgpexprPredicatesOnKey(pmp, pdrgpexprConjuncts, pcr, pcrsKeys, &pbsUsed);
const ULONG ulLen = pdrgpexprKey->UlLength();
if (0 == ulLen)
{
// no predicates on this key
pdrgpexprKey->Release();
continue;
}
if (1 < ulLen || (!CPredicateUtils::FEquality((*pdrgpexprKey)[0])))
{
// more than one predicate on this key or one non-equality predicate
#ifdef GPOS_DEBUG
BOOL fResult =
#endif // GPOS_DEBUG
phmulexprFilter->FInsert(GPOS_NEW(pmp) ULONG(ul), CPredicateUtils::PexprConjunction(pmp, pdrgpexprKey));
GPOS_ASSERT(fResult);
continue;
}
// one equality predicate (key = expr); take out the expression
// and add it to the equality filters map
CExpression *pexprPartKey = NULL;
CExpression *pexprOther = NULL;
IMDType::ECmpType ecmpt = IMDType::EcmptOther;
CPredicateUtils::ExtractComponents((*pdrgpexprKey)[0], pcr, &pexprPartKey, &pexprOther, &ecmpt);
GPOS_ASSERT(NULL != pexprOther);
pexprOther->AddRef();
#ifdef GPOS_DEBUG
BOOL fResult =
#endif // GPOS_DEBUG
phmulexprEqFilter->FInsert(GPOS_NEW(pmp) ULONG(ul), pexprOther);
GPOS_ASSERT(fResult);
pdrgpexprKey->Release();
}
(*ppexprResidual) = PexprResidualFilter(pmp, pdrgpexprConjuncts, pbsUsed);
pcrsKeys->Release();
pdrgpexprConjuncts->Release();
pbsUsed->Release();
}
//---------------------------------------------------------------------------
// @function:
// CJoinOrderTest::EresUnittest_Expand
//
// @doc:
// Simple expansion test
//
//---------------------------------------------------------------------------
GPOS_RESULT
CJoinOrderTest::EresUnittest_Expand()
{
CAutoMemoryPool amp;
IMemoryPool *pmp = amp.Pmp();
// setup a file-based provider
CMDProviderMemory *pmdp = CTestUtils::m_pmdpf;
pmdp->AddRef();
CMDAccessor mda(pmp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp);
// install opt context in TLS
CAutoOptCtxt aoc
(
pmp,
&mda,
NULL, /* pceeval */
CTestUtils::Pcm(pmp)
);
// build test case
CExpression *pexpr = CTestUtils::PexprLogicalNAryJoin(pmp);
DrgPexpr *pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp);
ULONG ulArity = pexpr->UlArity();
for (ULONG ul = 0; ul < ulArity - 1; ul++)
{
CExpression *pexprChild = (*pexpr)[ul];
pexprChild->AddRef();
pdrgpexpr->Append(pexprChild);
}
DrgPexpr *pdrgpexprConj = CPredicateUtils::PdrgpexprConjuncts(pmp, (*pexpr)[ulArity - 1]);
// add predicates selectively to trigger special case of cross join
DrgPexpr *pdrgpexprTest = GPOS_NEW(pmp) DrgPexpr(pmp);
for (ULONG ul = 0; ul < pdrgpexprConj->UlLength() - 1; ul++)
{
CExpression *pexprConjunct = (*pdrgpexprConj)[ul];
pexprConjunct->AddRef();
pdrgpexprTest->Append(pexprConjunct);
}
pdrgpexprConj->Release();
// single-table predicate
CColRefSet *pcrsOutput = CDrvdPropRelational::Pdprel((*pdrgpexpr)[ulArity - 2]->PdpDerive())->PcrsOutput();
CExpression *pexprSingleton = CUtils::PexprScalarEqCmp(pmp, pcrsOutput->PcrAny(), pcrsOutput->PcrAny());
pdrgpexprTest->Append(pexprSingleton);
CJoinOrder jo(pmp, pdrgpexpr, pdrgpexprTest);
CExpression *pexprResult = jo.PexprExpand();
{
CAutoTrace at(pmp);
at.Os() << std::endl << "INPUT:" << std::endl << *pexpr << std::endl;
at.Os() << std::endl << "OUTPUT:" << std::endl << *pexprResult << std::endl;
}
CRefCount::SafeRelease(pexprResult);
pexpr->Release();
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CDecorrelator::FProcessPredicate
//
// @doc:
// Decorrelate predicate
//
//---------------------------------------------------------------------------
BOOL
CDecorrelator::FProcessPredicate
(
IMemoryPool *pmp,
CExpression *pexprLogical, // logical parent of predicate tree
CExpression *pexprScalar,
BOOL fEqualityOnly,
CColRefSet *pcrsOutput,
CExpression **ppexprDecorrelated,
DrgPexpr *pdrgpexprCorrelations
)
{
GPOS_ASSERT(pexprLogical->Pop()->FLogical());
GPOS_ASSERT(pexprScalar->Pop()->FScalar());
*ppexprDecorrelated = NULL;
DrgPexpr *pdrgpexprConj = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprScalar);
DrgPexpr *pdrgpexprResiduals = GPOS_NEW(pmp) DrgPexpr(pmp);
BOOL fSuccess = true;
// divvy up the predicates in residuals (w/ no outer ref) and correlations (w/ outer refs)
ULONG ulLength = pdrgpexprConj->UlLength();
for(ULONG ul = 0; ul < ulLength && fSuccess; ul++)
{
CExpression *pexprConj = (*pdrgpexprConj)[ul];
CColRefSet *pcrsUsed = CDrvdPropScalar::Pdpscalar(pexprConj->PdpDerive())->PcrsUsed();
if (pcrsOutput->FSubset(pcrsUsed))
{
// no outer ref
pexprConj->AddRef();
pdrgpexprResiduals->Append(pexprConj);
continue;
}
fSuccess = FDelayable(pexprLogical, pexprConj, fEqualityOnly);
if (fSuccess)
{
pexprConj->AddRef();
pdrgpexprCorrelations->Append(pexprConj);
}
}
pdrgpexprConj->Release();
if (!fSuccess || 0 == pdrgpexprResiduals->UlLength())
{
// clean up
pdrgpexprResiduals->Release();
}
else
{
// residuals become new predicate
*ppexprDecorrelated = CPredicateUtils::PexprConjunction(pmp, pdrgpexprResiduals);
}
return fSuccess;
}
//---------------------------------------------------------------------------
// @function:
// CNormalizer::PushThruJoin
//
// @doc:
// Push a conjunct through a join
//
//
//---------------------------------------------------------------------------
void
CNormalizer::PushThruJoin
(
IMemoryPool *pmp,
CExpression *pexprJoin,
CExpression *pexprConj,
CExpression **ppexprResult
)
{
GPOS_ASSERT(NULL != pexprConj);
GPOS_ASSERT(NULL != ppexprResult);
COperator *pop = pexprJoin->Pop();
const ULONG ulArity = pexprJoin->UlArity();
BOOL fLASApply = CUtils::FLeftAntiSemiApply(pop);
COperator::EOperatorId eopid = pop->Eopid();
BOOL fOuterJoin =
COperator::EopLogicalLeftOuterJoin == eopid ||
COperator::EopLogicalLeftOuterApply == eopid ||
COperator::EopLogicalLeftOuterCorrelatedApply == eopid;
if (fOuterJoin && !CUtils::FScalarConstTrue(pexprConj))
{
// whenever possible, push incoming predicate through outer join's outer child,
// recursion will eventually reach the rest of PushThruJoin() to process join predicates
PushThruOuterChild(pmp, pexprJoin, pexprConj, ppexprResult);
return;
}
// combine conjunct with join predicate
CExpression *pexprScalar = (*pexprJoin)[ulArity - 1];
CExpression *pexprPred = CPredicateUtils::PexprConjunction(pmp, pexprScalar, pexprConj);
// break predicate to conjuncts
DrgPexpr *pdrgpexprConjuncts = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprPred);
pexprPred->Release();
// push predicates through children and compute new child expressions
DrgPexpr *pdrgpexprChildren = GPOS_NEW(pmp) DrgPexpr(pmp);
for (ULONG ul = 0; ul < ulArity - 1; ul++)
{
CExpression *pexprChild = (*pexprJoin)[ul];
CExpression *pexprNewChild = NULL;
if (fLASApply)
{
// do not push anti-semi-apply predicates to any of the children
pexprNewChild = PexprNormalize(pmp, pexprChild);
pdrgpexprChildren->Append(pexprNewChild);
continue;
}
if (0 == ul && fOuterJoin)
{
// do not push outer join predicates through outer child
// otherwise, we will throw away outer child's tuples that should
// be part of the join result
pexprNewChild = PexprNormalize(pmp, pexprChild);
pdrgpexprChildren->Append(pexprNewChild);
continue;
}
DrgPexpr *pdrgpexprRemaining = NULL;
PushThru(pmp, pexprChild, pdrgpexprConjuncts, &pexprNewChild, &pdrgpexprRemaining);
pdrgpexprChildren->Append(pexprNewChild);
pdrgpexprConjuncts->Release();
pdrgpexprConjuncts = pdrgpexprRemaining;
}
// remaining conjuncts become the new join predicate
CExpression *pexprNewScalar = CPredicateUtils::PexprConjunction(pmp, pdrgpexprConjuncts);
pdrgpexprChildren->Append(pexprNewScalar);
// create a new join expression
pop->AddRef();
*ppexprResult = GPOS_NEW(pmp) CExpression(pmp, pop, pdrgpexprChildren);
}
//---------------------------------------------------------------------------
// @function:
// CXformInnerApplyWithOuterKey2InnerJoin::Transform
//
// @doc:
// Actual transformation
//
//---------------------------------------------------------------------------
void
CXformInnerApplyWithOuterKey2InnerJoin::Transform
(
CXformContext *pxfctxt,
CXformResult *pxfres,
CExpression *pexpr
)
const
{
GPOS_ASSERT(NULL != pxfctxt);
GPOS_ASSERT(FPromising(pxfctxt->Pmp(), this, pexpr));
GPOS_ASSERT(FCheckPattern(pexpr));
IMemoryPool *pmp = pxfctxt->Pmp();
// extract components
CExpression *pexprOuter = (*pexpr)[0];
CExpression *pexprGb = (*pexpr)[1];
CExpression *pexprScalar = (*pexpr)[2];
if (0 < CLogicalGbAgg::PopConvert(pexprGb->Pop())->Pdrgpcr()->UlLength())
{
// xform is not applicable if inner Gb has grouping columns
return;
}
if (CUtils::FHasSubqueryOrApply((*pexprGb)[0]))
{
// Subquery/Apply must be unnested before reaching here
return;
}
// decorrelate Gb's relational child
(*pexprGb)[0]->ResetDerivedProperties();
CExpression *pexprInner = NULL;
DrgPexpr *pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp);
if (!CDecorrelator::FProcess(pmp, (*pexprGb)[0], false /*fEqualityOnly*/, &pexprInner, pdrgpexpr))
{
pdrgpexpr->Release();
return;
}
GPOS_ASSERT(NULL != pexprInner);
CExpression *pexprPredicate = CPredicateUtils::PexprConjunction(pmp, pdrgpexpr);
// join outer child with Gb's decorrelated child
pexprOuter->AddRef();
CExpression *pexprInnerJoin =
GPOS_NEW(pmp) CExpression
(
pmp,
GPOS_NEW(pmp) CLogicalInnerJoin(pmp),
pexprOuter,
pexprInner,
pexprPredicate
);
// create grouping columns from the output of outer child
DrgPcr *pdrgpcrKey = NULL;
DrgPcr *pdrgpcr = CUtils::PdrgpcrGroupingKey(pmp, pexprOuter, &pdrgpcrKey);
pdrgpcrKey->Release(); // key is not used here
CLogicalGbAgg *popGbAgg = GPOS_NEW(pmp) CLogicalGbAgg(pmp, pdrgpcr, COperator::EgbaggtypeGlobal /*egbaggtype*/);
CExpression *pexprPrjList = (*pexprGb)[1];
pexprPrjList->AddRef();
CExpression *pexprNewGb = GPOS_NEW(pmp) CExpression (pmp, popGbAgg, pexprInnerJoin, pexprPrjList);
// add Apply predicate in a top Select node
pexprScalar->AddRef();
CExpression *pexprSelect = CUtils::PexprLogicalSelect(pmp, pexprNewGb, pexprScalar);
pxfres->Add(pexprSelect);
}
//---------------------------------------------------------------------------
// @function:
// CXformSelect2PartialDynamicIndexGet::CreatePartialIndexGetPlan
//
// @doc:
// Create a plan as a union of the given partial index get candidates and
// possibly a dynamic table scan
//
//---------------------------------------------------------------------------
void
CXformSelect2PartialDynamicIndexGet::CreatePartialIndexGetPlan
(
IMemoryPool *pmp,
CExpression *pexpr,
DrgPpartdig *pdrgppartdig,
const IMDRelation *pmdrel,
CXformResult *pxfres
)
const
{
CExpression *pexprRelational = (*pexpr)[0];
CExpression *pexprScalar = (*pexpr)[1];
CLogicalDynamicGet *popGet = CLogicalDynamicGet::PopConvert(pexprRelational->Pop());
DrgPcr *pdrgpcrGet = popGet->PdrgpcrOutput();
const ULONG ulPartialIndexes = pdrgppartdig->UlLength();
DrgDrgPcr *pdrgpdrgpcrInput = GPOS_NEW(pmp) DrgDrgPcr(pmp);
DrgPexpr *pdrgpexprInput = GPOS_NEW(pmp) DrgPexpr(pmp);
for (ULONG ul = 0; ul < ulPartialIndexes; ul++)
{
SPartDynamicIndexGetInfo *ppartdig = (*pdrgppartdig)[ul];
const IMDIndex *pmdindex = ppartdig->m_pmdindex;
CPartConstraint *ppartcnstr = ppartdig->m_ppartcnstr;
DrgPexpr *pdrgpexprIndex = ppartdig->m_pdrgpexprIndex;
DrgPexpr *pdrgpexprResidual = ppartdig->m_pdrgpexprResidual;
DrgPcr *pdrgpcrNew = pdrgpcrGet;
if (0 < ul)
{
pdrgpcrNew = CUtils::PdrgpcrCopy(pmp, pdrgpcrGet);
}
else
{
pdrgpcrNew->AddRef();
}
CExpression *pexprDynamicScan = NULL;
if (NULL != pmdindex)
{
pexprDynamicScan = CXformUtils::PexprPartialDynamicIndexGet
(
pmp,
popGet,
pexpr->Pop()->UlOpId(),
pdrgpexprIndex,
pdrgpexprResidual,
pdrgpcrNew,
pmdindex,
pmdrel,
ppartcnstr,
NULL, // pcrsAcceptedOuterRefs
NULL, // pdrgpcrOuter
NULL // pdrgpcrNewOuter
);
}
else
{
pexprDynamicScan = PexprSelectOverDynamicGet
(
pmp,
popGet,
pexprScalar,
pdrgpcrNew,
ppartcnstr
);
}
GPOS_ASSERT(NULL != pexprDynamicScan);
pdrgpdrgpcrInput->Append(pdrgpcrNew);
pdrgpexprInput->Append(pexprDynamicScan);
}
ULONG ulInput = pdrgpexprInput->UlLength();
if (0 < ulInput)
{
CExpression *pexprResult = NULL;
if (1 < ulInput)
{
pdrgpcrGet->AddRef();
DrgPcr *pdrgpcrOuter = pdrgpcrGet;
// construct a new union all operator
pexprResult = GPOS_NEW(pmp) CExpression
(
pmp,
GPOS_NEW(pmp) CLogicalUnionAll(pmp, pdrgpcrOuter, pdrgpdrgpcrInput, popGet->UlScanId()),
pdrgpexprInput
);
}
else
{
pexprResult = (*pdrgpexprInput)[0];
pexprResult->AddRef();
// clean up
pdrgpexprInput->Release();
pdrgpdrgpcrInput->Release();
}
// if scalar expression involves the partitioning key, keep a SELECT node
// on top for the purposes of partition selection
DrgDrgPcr *pdrgpdrgpcrPartKeys = popGet->PdrgpdrgpcrPart();
CExpression *pexprPredOnPartKey = CPredicateUtils::PexprExtractPredicatesOnPartKeys
(
pmp,
pexprScalar,
pdrgpdrgpcrPartKeys,
NULL, /*pcrsAllowedRefs*/
true /*fUseConstraints*/
);
if (NULL != pexprPredOnPartKey)
{
pexprResult = GPOS_NEW(pmp) CExpression(pmp, GPOS_NEW(pmp) CLogicalSelect(pmp), pexprResult, pexprPredOnPartKey);
}
pxfres->Add(pexprResult);
return;
}
// clean up
pdrgpdrgpcrInput->Release();
pdrgpexprInput->Release();
}
//---------------------------------------------------------------------------
// @function:
// CNormalizer::PexprPullUpAndCombineProjects
//
// @doc:
// Pulls up logical projects as far as possible, and combines consecutive
// projects if possible
//
//---------------------------------------------------------------------------
CExpression *
CNormalizer::PexprPullUpAndCombineProjects
(
IMemoryPool *pmp,
CExpression *pexpr,
BOOL *pfSuccess // output to indicate whether anything was pulled up
)
{
GPOS_ASSERT(NULL != pexpr);
GPOS_ASSERT(NULL != pfSuccess);
COperator *pop = pexpr->Pop();
const ULONG ulArity = pexpr->UlArity();
if (!pop->FLogical() || 0 == ulArity)
{
pexpr->AddRef();
return pexpr;
}
DrgPexpr *pdrgpexprChildren = GPOS_NEW(pmp) DrgPexpr(pmp);
DrgPexpr *pdrgpexprPrElPullUp = GPOS_NEW(pmp) DrgPexpr(pmp);
CExpressionHandle exprhdl(pmp);
exprhdl.Attach(pexpr);
CColRefSet *pcrsOutput = CDrvdPropRelational::Pdprel(pexpr->PdpDerive())->PcrsOutput();
// extract the columns used by the scalar expression and the operator itself (for grouping, sorting, etc.)
CColRefSet *pcrsUsed = exprhdl.PcrsUsedColumns(pmp);
for (ULONG ul = 0; ul < ulArity; ul++)
{
CExpression *pexprChild = PexprPullUpAndCombineProjects(pmp, (*pexpr)[ul], pfSuccess);
if (pop->FLogical() && CLogical::PopConvert(pop)->FCanPullProjectionsUp(ul) &&
COperator::EopLogicalProject == pexprChild->Pop()->Eopid())
{
// this child is a project - see if any project elements can be pulled up
CExpression *pexprNewChild = PexprPullUpProjectElements
(
pmp,
pexprChild,
pcrsUsed,
pcrsOutput,
&pdrgpexprPrElPullUp
);
pexprChild->Release();
pexprChild = pexprNewChild;
}
pdrgpexprChildren->Append(pexprChild);
}
pcrsUsed->Release();
pop->AddRef();
if (0 < pdrgpexprPrElPullUp->UlLength() && COperator::EopLogicalProject == pop->Eopid())
{
// some project elements have been pulled up and the original expression
// was a project - combine its project list with the pulled up project elements
GPOS_ASSERT(2 == pdrgpexprChildren->UlLength());
*pfSuccess = true;
CExpression *pexprRelational = (*pdrgpexprChildren)[0];
CExpression *pexprPrLOld = (*pdrgpexprChildren)[1];
pexprRelational->AddRef();
CUtils::AddRefAppend(pdrgpexprPrElPullUp, pexprPrLOld->PdrgPexpr());
pdrgpexprChildren->Release();
CExpression *pexprPrjList = GPOS_NEW(pmp) CExpression(pmp, GPOS_NEW(pmp) CScalarProjectList(pmp), pdrgpexprPrElPullUp);
GPOS_ASSERT(CDrvdPropRelational::Pdprel(pexprRelational->PdpDerive())->PcrsOutput()->FSubset(CDrvdPropScalar::Pdpscalar(pexprPrjList->PdpDerive())->PcrsUsed()));
return GPOS_NEW(pmp) CExpression(pmp, pop, pexprRelational, pexprPrjList);
}
CExpression *pexprOutput = GPOS_NEW(pmp) CExpression(pmp, pop, pdrgpexprChildren);
if (0 == pdrgpexprPrElPullUp->UlLength())
{
// no project elements were pulled up
pdrgpexprPrElPullUp->Release();
return pexprOutput;
}
// some project elements were pulled - add a project on top of output expression
*pfSuccess = true;
CExpression *pexprPrjList = GPOS_NEW(pmp) CExpression(pmp, GPOS_NEW(pmp) CScalarProjectList(pmp), pdrgpexprPrElPullUp);
GPOS_ASSERT(CDrvdPropRelational::Pdprel(pexprOutput->PdpDerive())->PcrsOutput()->FSubset(CDrvdPropScalar::Pdpscalar(pexprPrjList->PdpDerive())->PcrsUsed()));
return GPOS_NEW(pmp) CExpression(pmp, GPOS_NEW(pmp) CLogicalProject(pmp), pexprOutput, pexprPrjList);
}
//---------------------------------------------------------------------------
// @function:
// CNormalizer::PexprPullUpProjectElements
//
// @doc:
// Pull up project elements from the given projection expression that do not
// exist in the given used columns set. The pulled up project elements must only
// use columns that are in the output columns of the parent operator. Returns
// a new expression that does not have the pulled up project elements. These
// project elements are appended to the given array.
//
//---------------------------------------------------------------------------
CExpression *
CNormalizer::PexprPullUpProjectElements
(
IMemoryPool *pmp,
CExpression *pexpr,
CColRefSet *pcrsUsed,
CColRefSet *pcrsOutput,
DrgPexpr **ppdrgpexprPrElPullUp // output: the pulled-up project elements
)
{
GPOS_ASSERT(NULL != pexpr);
GPOS_ASSERT(COperator::EopLogicalProject == pexpr->Pop()->Eopid());
GPOS_ASSERT(NULL != pcrsUsed);
GPOS_ASSERT(NULL != ppdrgpexprPrElPullUp);
GPOS_ASSERT(NULL != *ppdrgpexprPrElPullUp);
if (2 != pexpr->UlArity())
{
// the project's children were not extracted as part of the pattern in this xform
GPOS_ASSERT(0 == pexpr->UlArity());
pexpr->AddRef();
return pexpr;
}
DrgPexpr *pdrgpexprPrElNoPullUp = GPOS_NEW(pmp) DrgPexpr(pmp);
CExpression *pexprPrL = (*pexpr)[1];
const ULONG ulProjElements = pexprPrL->UlArity();
for (ULONG ul = 0; ul < ulProjElements; ul++)
{
CExpression *pexprPrEl = (*pexprPrL)[ul];
CScalarProjectElement *popPrEl = CScalarProjectElement::PopConvert(pexprPrEl->Pop());
CColRef *pcrDefined = popPrEl->Pcr();
CColRefSet *pcrsUsedByProjElem = CDrvdPropScalar::Pdpscalar(pexprPrEl->PdpDerive())->PcrsUsed();
// a proj elem can be pulled up only if the defined column is not in
// pcrsUsed and its used columns are in pcrOutput
pexprPrEl->AddRef();
if (!pcrsUsed->FMember(pcrDefined) && pcrsOutput->FSubset(pcrsUsedByProjElem))
{
(*ppdrgpexprPrElPullUp)->Append(pexprPrEl);
}
else
{
pdrgpexprPrElNoPullUp->Append(pexprPrEl);
}
}
CExpression *pexprNew = (*pexpr)[0];
pexprNew->AddRef();
if (0 == pdrgpexprPrElNoPullUp->UlLength())
{
pdrgpexprPrElNoPullUp->Release();
}
else
{
// some project elements could not be pulled up - need a project here
CExpression *pexprPrjList = GPOS_NEW(pmp) CExpression(pmp, GPOS_NEW(pmp) CScalarProjectList(pmp), pdrgpexprPrElNoPullUp);
pexprNew = GPOS_NEW(pmp) CExpression(pmp, GPOS_NEW(pmp) CLogicalProject(pmp), pexprNew, pexprPrjList);
}
return pexprNew;
}
//---------------------------------------------------------------------------
// @function:
// CXformSelect2PartialDynamicIndexGet::Transform
//
// @doc:
// Actual transformation
//
//---------------------------------------------------------------------------
void
CXformSelect2PartialDynamicIndexGet::Transform
(
CXformContext *pxfctxt,
CXformResult *pxfres,
CExpression *pexpr
)
const
{
GPOS_ASSERT(NULL != pxfctxt);
GPOS_ASSERT(FPromising(pxfctxt->Pmp(), this, pexpr));
GPOS_ASSERT(FCheckPattern(pexpr));
IMemoryPool *pmp = pxfctxt->Pmp();
// extract components
CExpression *pexprRelational = (*pexpr)[0];
CExpression *pexprScalar = (*pexpr)[1];
// get the indexes on this relation
CLogicalDynamicGet *popGet = CLogicalDynamicGet::PopConvert(pexprRelational->Pop());
if (popGet->FPartial())
{
// already a partial dynamic get; do not try to split further
return;
}
CTableDescriptor *ptabdesc = popGet->Ptabdesc();
CMDAccessor *pmda = COptCtxt::PoctxtFromTLS()->Pmda();
const IMDRelation *pmdrel = pmda->Pmdrel(ptabdesc->Pmdid());
const ULONG ulIndices = pmdrel->UlIndices();
if (0 == ulIndices)
{
// no indexes on the table
return;
}
// array of expressions in the scalar expression
DrgPexpr *pdrgpexpr = CPredicateUtils::PdrgpexprConjuncts(pmp, pexprScalar);
GPOS_ASSERT(0 < pdrgpexpr->UlLength());
// derive the scalar and relational properties to build set of required columns
CColRefSet *pcrsOutput = CDrvdPropRelational::Pdprel(pexpr->PdpDerive())->PcrsOutput();
CColRefSet *pcrsScalarExpr = CDrvdPropScalar::Pdpscalar(pexprScalar->PdpDerive())->PcrsUsed();
CColRefSet *pcrsReqd = GPOS_NEW(pmp) CColRefSet(pmp);
pcrsReqd->Include(pcrsOutput);
pcrsReqd->Include(pcrsScalarExpr);
CPartConstraint *ppartcnstr = popGet->Ppartcnstr();
ppartcnstr->AddRef();
// find a candidate set of partial index combinations
DrgPdrgPpartdig *pdrgpdrgppartdig = CXformUtils::PdrgpdrgppartdigCandidates
(
pmp,
pmda,
pdrgpexpr,
popGet->PdrgpdrgpcrPart(),
pmdrel,
ppartcnstr,
popGet->PdrgpcrOutput(),
pcrsReqd,
pcrsScalarExpr,
NULL // pcrsAcceptedOuterRefs
);
// construct alternative partial index scan plans
const ULONG ulCandidates = pdrgpdrgppartdig->UlLength();
for (ULONG ul = 0; ul < ulCandidates; ul++)
{
DrgPpartdig *pdrgppartdig = (*pdrgpdrgppartdig)[ul];
CreatePartialIndexGetPlan(pmp, pexpr, pdrgppartdig, pmdrel, pxfres);
}
ppartcnstr->Release();
pcrsReqd->Release();
pdrgpexpr->Release();
pdrgpdrgppartdig->Release();
}
//---------------------------------------------------------------------------
// @function:
// CXformJoinAssociativity::CreatePredicates
//
// @doc:
// Extract all conjuncts and divvy them up between upper and lower join
//
//---------------------------------------------------------------------------
void
CXformJoinAssociativity::CreatePredicates
(
IMemoryPool *pmp,
CExpression *pexpr,
DrgPexpr *pdrgpexprLower,
DrgPexpr *pdrgpexprUpper
)
const
{
GPOS_CHECK_ABORT;
// bind operators
CExpression *pexprLeft = (*pexpr)[0];
CExpression *pexprLeftLeft = (*pexprLeft)[0];
CExpression *pexprRight = (*pexpr)[1];
DrgPexpr *pdrgpexprJoins = GPOS_NEW(pmp) DrgPexpr(pmp);
pexprLeft->AddRef();
pdrgpexprJoins->Append(pexprLeft);
pexpr->AddRef();
pdrgpexprJoins->Append(pexpr);
// columns for new lower join
CColRefSet *pcrsLower = GPOS_NEW(pmp) CColRefSet(pmp);
pcrsLower->Union(CDrvdPropRelational::Pdprel(pexprLeftLeft->PdpDerive())->PcrsOutput());
pcrsLower->Union(CDrvdPropRelational::Pdprel(pexprRight->PdpDerive())->PcrsOutput());
// convert current predicates into arrays of conjuncts
DrgPexpr *pdrgpexprOrig = GPOS_NEW(pmp) DrgPexpr(pmp);
for (ULONG ul = 0; ul < 2; ul++)
{
DrgPexpr *pdrgpexprPreds = CPredicateUtils::PdrgpexprConjuncts(pmp, (*(*pdrgpexprJoins)[ul])[2]);
ULONG ulLen = pdrgpexprPreds->UlLength();
for (ULONG ulConj = 0; ulConj < ulLen; ulConj++)
{
CExpression *pexprConj = (*pdrgpexprPreds)[ulConj];
pexprConj->AddRef();
pdrgpexprOrig->Append(pexprConj);
}
pdrgpexprPreds->Release();
}
// divvy up conjuncts for upper and lower join
ULONG ulConj = pdrgpexprOrig->UlLength();
for (ULONG ul = 0; ul < ulConj; ul++)
{
CExpression *pexprPred = (*pdrgpexprOrig)[ul];
CColRefSet *pcrs = CDrvdPropScalar::Pdpscalar(pexprPred->PdpDerive())->PcrsUsed();
pexprPred->AddRef();
if (pcrsLower->FSubset(pcrs))
{
pdrgpexprLower->Append(pexprPred);
}
else
{
pdrgpexprUpper->Append(pexprPred);
}
}
// No predicates indicate a cross join. And for that, ORCA expects
// predicate to be a scalar const "true".
if (pdrgpexprLower->UlLength() == 0)
{
CExpression *pexprCrossLowerJoinPred = CUtils::PexprScalarConstBool(pmp, true, false);
pdrgpexprLower->Append(pexprCrossLowerJoinPred);
}
// Same for upper predicates
if (pdrgpexprUpper->UlLength() == 0)
{
CExpression *pexprCrossUpperJoinPred = CUtils::PexprScalarConstBool(pmp, true, false);
pdrgpexprUpper->Append(pexprCrossUpperJoinPred);
}
// clean up
pcrsLower->Release();
pdrgpexprOrig->Release();
pdrgpexprJoins->Release();
}
//---------------------------------------------------------------------------
// @function:
// CJoinOrderTest::EresUnittest_ExpandMinCard
//
// @doc:
// Expansion expansion based on cardinality of intermediate results
//
//---------------------------------------------------------------------------
GPOS_RESULT
CJoinOrderTest::EresUnittest_ExpandMinCard()
{
CAutoMemoryPool amp;
IMemoryPool *pmp = amp.Pmp();
// array of relation names
CWStringConst rgscRel[] =
{
GPOS_WSZ_LIT("Rel10"),
GPOS_WSZ_LIT("Rel3"),
GPOS_WSZ_LIT("Rel4"),
GPOS_WSZ_LIT("Rel6"),
GPOS_WSZ_LIT("Rel7"),
GPOS_WSZ_LIT("Rel8"),
GPOS_WSZ_LIT("Rel12"),
GPOS_WSZ_LIT("Rel13"),
GPOS_WSZ_LIT("Rel5"),
GPOS_WSZ_LIT("Rel14"),
GPOS_WSZ_LIT("Rel15"),
GPOS_WSZ_LIT("Rel1"),
GPOS_WSZ_LIT("Rel11"),
GPOS_WSZ_LIT("Rel2"),
GPOS_WSZ_LIT("Rel9"),
};
// array of relation IDs
ULONG rgulRel[] =
{
GPOPT_TEST_REL_OID10,
GPOPT_TEST_REL_OID3,
GPOPT_TEST_REL_OID4,
GPOPT_TEST_REL_OID6,
GPOPT_TEST_REL_OID7,
GPOPT_TEST_REL_OID8,
GPOPT_TEST_REL_OID12,
GPOPT_TEST_REL_OID13,
GPOPT_TEST_REL_OID5,
GPOPT_TEST_REL_OID14,
GPOPT_TEST_REL_OID15,
GPOPT_TEST_REL_OID1,
GPOPT_TEST_REL_OID11,
GPOPT_TEST_REL_OID2,
GPOPT_TEST_REL_OID9,
};
const ULONG ulRels = GPOS_ARRAY_SIZE(rgscRel);
GPOS_ASSERT(GPOS_ARRAY_SIZE(rgulRel) == ulRels);
// setup a file-based provider
CMDProviderMemory *pmdp = CTestUtils::m_pmdpf;
pmdp->AddRef();
CMDAccessor mda(pmp, CMDCache::Pcache());
mda.RegisterProvider(CTestUtils::m_sysidDefault, pmdp);
{
// install opt context in TLS
CAutoOptCtxt aoc
(
pmp,
&mda,
NULL, /* pceeval */
CTestUtils::Pcm(pmp)
);
CExpression *pexprNAryJoin =
CTestUtils::PexprLogicalNAryJoin(pmp, rgscRel, rgulRel, ulRels, false /*fCrossProduct*/);
// derive stats on input expression
CExpressionHandle exprhdl(pmp);
exprhdl.Attach(pexprNAryJoin);
exprhdl.DeriveStats(pmp, pmp, NULL /*prprel*/, NULL /*pdrgpstatCtxt*/);
DrgPexpr *pdrgpexpr = GPOS_NEW(pmp) DrgPexpr(pmp);
for (ULONG ul = 0; ul < ulRels; ul++)
{
CExpression *pexprChild = (*pexprNAryJoin)[ul];
pexprChild->AddRef();
pdrgpexpr->Append(pexprChild);
}
DrgPexpr *pdrgpexprPred = CPredicateUtils::PdrgpexprConjuncts(pmp, (*pexprNAryJoin)[ulRels]);
pdrgpexpr->AddRef();
pdrgpexprPred->AddRef();
CJoinOrderMinCard jomc(pmp, pdrgpexpr, pdrgpexprPred);
CExpression *pexprResult = jomc.PexprExpand();
{
CAutoTrace at(pmp);
at.Os() << std::endl << "INPUT:" << std::endl << *pexprNAryJoin << std::endl;
at.Os() << std::endl << "OUTPUT:" << std::endl << *pexprResult << std::endl;
}
pexprResult->Release();
pexprNAryJoin->Release();
pdrgpexpr->Release();
pdrgpexprPred->Release();
}
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CNormalizer::PushThruOuterChild
//
// @doc:
// Push scalar expression through left outer join children;
// this only handles the case of a SELECT on top of LEFT OUTER JOIN;
// pushing down join predicates is handled in PushThruJoin();
// here, we push predicates of the top SELECT node through LEFT OUTER JOIN's
// outer child
//
//---------------------------------------------------------------------------
void
CNormalizer::PushThruOuterChild
(
IMemoryPool *pmp,
CExpression *pexpr,
CExpression *pexprConj,
CExpression **ppexprResult
)
{
GPOS_ASSERT(NULL != pexpr);
GPOS_ASSERT(FPushThruOuterChild(pexpr));
GPOS_ASSERT(NULL != pexprConj);
GPOS_ASSERT(NULL != ppexprResult);
if (0 == pexpr->UlArity())
{
// end recursion early for leaf patterns extracted from memo
pexpr->AddRef();
pexprConj->AddRef();
*ppexprResult = CUtils::PexprSafeSelect(pmp, pexpr, pexprConj);
return;
}
CExpression *pexprOuter = (*pexpr)[0];
CExpression *pexprInner = (*pexpr)[1];
CExpression *pexprPred = (*pexpr)[2];
DrgPexpr *pdrgpexprPushable = NULL;
DrgPexpr *pdrgpexprUnpushable = NULL;
SplitConjunct(pmp, pexprOuter, pexprConj, &pdrgpexprPushable, &pdrgpexprUnpushable);
if (0 < pdrgpexprPushable->UlLength())
{
pdrgpexprPushable->AddRef();
CExpression *pexprNewConj = CPredicateUtils::PexprConjunction(pmp, pdrgpexprPushable);
// create a new select node on top of the outer child
pexprOuter->AddRef();
CExpression *pexprNewSelect =
GPOS_NEW(pmp) CExpression(pmp, GPOS_NEW(pmp) CLogicalSelect(pmp), pexprOuter, pexprNewConj);
// push predicate through the new select to create a new outer child
CExpression *pexprNewOuter = NULL;
PushThru(pmp, pexprNewSelect, pexprNewConj, &pexprNewOuter);
pexprNewSelect->Release();
// create a new outer join using the new outer child and the new inner child
COperator *pop = pexpr->Pop();
pop->AddRef();
pexprInner->AddRef();
pexprPred->AddRef();
CExpression *pexprNew = GPOS_NEW(pmp) CExpression(pmp, pop, pexprNewOuter, pexprInner, pexprPred);
// call push down predicates on the new outer join
CExpression *pexprConstTrue = CUtils::PexprScalarConstBool(pmp, true /*fVal*/);
PushThru(pmp, pexprNew, pexprConstTrue, ppexprResult);
pexprConstTrue->Release();
pexprNew->Release();
}
if (0 < pdrgpexprUnpushable->UlLength())
{
CExpression *pexprOuterJoin = pexpr;
if (0 < pdrgpexprPushable->UlLength())
{
pexprOuterJoin = *ppexprResult;
GPOS_ASSERT(NULL != pexprOuterJoin);
}
// call push down on the outer join predicates
CExpression *pexprNew = NULL;
CExpression *pexprConstTrue = CUtils::PexprScalarConstBool(pmp, true /*fVal*/);
PushThru(pmp, pexprOuterJoin, pexprConstTrue, &pexprNew);
if (pexprOuterJoin != pexpr)
{
pexprOuterJoin->Release();
}
pexprConstTrue->Release();
// create a SELECT on top of the new outer join
pdrgpexprUnpushable->AddRef();
*ppexprResult = PexprSelect(pmp, pexprNew, pdrgpexprUnpushable);
}
pdrgpexprPushable->Release();
pdrgpexprUnpushable->Release();
}
