greenplumn CExpressionHandle 代码
文件路径：/src/backend/gporca/libgpopt/src/operators/CExpressionHandle.cpp
/---------------------------------------------------------------------------
/ Greenplum Database
/ Copyright (C) 2009 Greenplum, Inc.
/
/ @filename:
/ CExpressionHandle.cpp
/
/ @doc:
/ Handle to an expression to abstract topology;
/
/ The handle provides access to an expression and the properties
/ of its children; regardless of whether the expression is a group
/ expression or a stand-alone tree;
/---------------------------------------------------------------------------
#include "gpopt/operators/CExpressionHandle.h"
#include "gpos/base.h"
#include "gpopt/base/CCTEReq.h"
#include "gpopt/base/CColRefSet.h"
#include "gpopt/base/CCostContext.h"
#include "gpopt/base/CDrvdPropCtxtPlan.h"
#include "gpopt/base/CDrvdPropScalar.h"
#include "gpopt/base/CKeyCollection.h"
#include "gpopt/base/COptCtxt.h"
#include "gpopt/base/CReqdPropPlan.h"
#include "gpopt/base/CUtils.h"
#include "gpopt/exception.h"
#include "gpopt/operators/CLogical.h"
#include "gpopt/operators/CLogicalCTEConsumer.h"
#include "gpopt/operators/CLogicalGbAgg.h"
#include "gpopt/operators/COperator.h"
#include "gpopt/operators/CPattern.h"
#include "gpopt/operators/CPhysicalCTEConsumer.h"
#include "gpopt/operators/CPhysicalScan.h"
#include "naucrates/statistics/CStatisticsUtils.h"
using namespace gpnaucrates;
using namespace gpopt;
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::CExpressionHandle
/
/ @doc:
/ ctor
/
/---------------------------------------------------------------------------
CExpressionHandle::CExpressionHandle(CMemoryPool *mp)
: m_mp(mp),
m_pexpr(nullptr),
m_pgexpr(nullptr),
m_pcc(nullptr),
m_pdpplan(nullptr),
m_pstats(nullptr),
m_prp(nullptr),
m_pdrgpstat(nullptr),
m_pdrgprp(nullptr)
{
GPOS_ASSERT(nullptr != mp);
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::~CExpressionHandle
/
/ @doc:
/ dtor
/
/ Since handles live on the stack this dtor will be called during
/ exceptions, hence, need to be defensive
/
/---------------------------------------------------------------------------
CExpressionHandle::~CExpressionHandle()
{
CRefCount::SafeRelease(m_pexpr);
CRefCount::SafeRelease(m_pgexpr);
CRefCount::SafeRelease(m_pstats);
CRefCount::SafeRelease(m_prp);
CRefCount::SafeRelease(m_pdpplan);
CRefCount::SafeRelease(m_pdrgpstat);
CRefCount::SafeRelease(m_pdrgprp);
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::FStatsDerived
/
/ @doc:
/ Check if stats are derived for attached expression and its children
/
/---------------------------------------------------------------------------
BOOL
CExpressionHandle::FStatsDerived() const
{
IStatistics *stats = nullptr;
if (nullptr != m_pexpr)
{
stats = const_cast<IStatistics *>(m_pexpr->Pstats());
}
else
{
GPOS_ASSERT(nullptr != m_pgexpr);
stats = m_pgexpr->Pgroup()->Pstats();
}
if (nullptr == stats)
{
/ stats of attached expression have not been derived yet
return false;
}
const ULONG arity = Arity();
for (ULONG ul = 0; ul < arity; ul++)
{
if (FScalarChild(ul))
{
/ skip scalar children
continue;
}
IStatistics *child_stats = nullptr;
if (nullptr != m_pexpr)
{
child_stats = const_cast<IStatistics *>((*m_pexpr)[ul]->Pstats());
}
else
{
child_stats = (*m_pgexpr)[ul]->Pstats();
}
if (nullptr == child_stats)
{
/ stats of attached expression child have not been derived yet
return false;
}
}
return true;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::CopyStats
/
/ @doc:
/ Copy stats from attached expression/group expression to local stats
/ members
/
/---------------------------------------------------------------------------
void
CExpressionHandle::CopyStats()
{
if (!FStatsDerived())
{
/ stats of attached expression (or its children) have not been derived yet
return;
}
IStatistics *stats = nullptr;
if (nullptr != m_pexpr)
{
stats = const_cast<IStatistics *>(m_pexpr->Pstats());
}
else
{
GPOS_ASSERT(nullptr != m_pgexpr);
stats = m_pgexpr->Pgroup()->Pstats();
}
GPOS_ASSERT(nullptr != stats);
/ attach stats
stats->AddRef();
GPOS_ASSERT(nullptr == m_pstats);
m_pstats = stats;
/ attach child stats
GPOS_ASSERT(nullptr == m_pdrgpstat);
m_pdrgpstat = GPOS_NEW(m_mp) IStatisticsArray(m_mp);
const ULONG arity = Arity();
for (ULONG ul = 0; ul < arity; ul++)
{
IStatistics *child_stats = nullptr;
if (nullptr != m_pexpr)
{
child_stats = const_cast<IStatistics *>((*m_pexpr)[ul]->Pstats());
}
else
{
child_stats = (*m_pgexpr)[ul]->Pstats();
}
if (nullptr != child_stats)
{
child_stats->AddRef();
}
else
{
GPOS_ASSERT(FScalarChild(ul));
/ create dummy stats for missing scalar children
child_stats = CStatistics::MakeEmptyStats(m_mp);
}
m_pdrgpstat->Append(child_stats);
}
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::Attach
/
/ @doc:
/ Attach to a given expression
/
/---------------------------------------------------------------------------
void
CExpressionHandle::Attach(CExpression *pexpr)
{
GPOS_ASSERT(nullptr == m_pexpr);
GPOS_ASSERT(nullptr == m_pgexpr);
GPOS_ASSERT(nullptr != pexpr);
/ increment ref count on base expression
pexpr->AddRef();
m_pexpr = pexpr;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::Attach
/
/ @doc:
/ Attach to a given group expression
/
/---------------------------------------------------------------------------
void
CExpressionHandle::Attach(CGroupExpression *pgexpr)
{
GPOS_ASSERT(nullptr == m_pexpr);
GPOS_ASSERT(nullptr == m_pgexpr);
GPOS_ASSERT(nullptr != pgexpr);
/ increment ref count on group expression
pgexpr->AddRef();
m_pgexpr = pgexpr;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::Attach
/
/ @doc:
/ Attach to a given cost context
/
/---------------------------------------------------------------------------
void
CExpressionHandle::Attach(CCostContext *pcc)
{
GPOS_ASSERT(nullptr == m_pcc);
GPOS_ASSERT(nullptr != pcc);
m_pcc = pcc;
Attach(pcc->Pgexpr());
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::DeriveProps
/
/ @doc:
/ Recursive property derivation
/
/---------------------------------------------------------------------------
void
CExpressionHandle::DeriveProps(CDrvdPropCtxt *pdpctxt)
{
GPOS_CHECK_ABORT;
if (nullptr != m_pgexpr)
{
return;
}
if (nullptr != m_pexpr->Pdp(m_pexpr->Ept()))
{
return;
}
/ copy stats of attached expression
CopyStats();
m_pexpr->PdpDerive(pdpctxt);
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::PdrgpstatOuterRefs
/
/ @doc:
/ Given an array of stats objects and a child index, return an array
/ of stats objects starting from the first stats object referenced by
/ child
/
/---------------------------------------------------------------------------
IStatisticsArray *
CExpressionHandle::PdrgpstatOuterRefs(IStatisticsArray *statistics_array,
ULONG child_index)
{
GPOS_ASSERT(nullptr != statistics_array);
GPOS_ASSERT(child_index < Arity());
if (FScalarChild(child_index) || !HasOuterRefs(child_index))
{
/ if child is scalar or has no outer references, return empty array
return GPOS_NEW(m_mp) IStatisticsArray(m_mp);
}
IStatisticsArray *pdrgpstatResult = GPOS_NEW(m_mp) IStatisticsArray(m_mp);
CColRefSet *outer_refs = DeriveOuterReferences(child_index);
GPOS_ASSERT(0 < outer_refs->Size());
const ULONG size = statistics_array->Size();
ULONG ulStartIndex = gpos::ulong_max;
for (ULONG ul = 0; ul < size; ul++)
{
IStatistics *stats = (*statistics_array)[ul];
CColRefSet *pcrsStats = stats->GetColRefSet(m_mp);
BOOL fStatsColsUsed = !outer_refs->IsDisjoint(pcrsStats);
pcrsStats->Release();
if (fStatsColsUsed)
{
ulStartIndex = ul;
break;
}
}
if (gpos::ulong_max != ulStartIndex)
{
/ copy stats starting from index of outer-most stats object referenced by child
CUtils::AddRefAppend(pdrgpstatResult, statistics_array, ulStartIndex);
}
return pdrgpstatResult;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::FAttachedToLeafPattern
/
/ @doc:
/ Return True if handle is attached to a leaf pattern
/
/---------------------------------------------------------------------------
BOOL
CExpressionHandle::FAttachedToLeafPattern() const
{
return 0 == Arity() && nullptr != m_pexpr && nullptr != m_pexpr->Pgexpr();
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::DeriveRootStats
/
/ @doc:
/ CheckState derivation at root operator where handle is attached
/
/---------------------------------------------------------------------------
void
CExpressionHandle::DeriveRootStats(IStatisticsArray *stats_ctxt)
{
GPOS_ASSERT(nullptr == m_pstats);
CLogical *popLogical = CLogical::PopConvert(Pop());
IStatistics *pstatsRoot = nullptr;
if (FAttachedToLeafPattern())
{
/ for leaf patterns extracted from memo, trigger state derivation on origin group
GPOS_ASSERT(nullptr != m_pexpr);
GPOS_ASSERT(nullptr != m_pexpr->Pgexpr());
pstatsRoot = m_pexpr->Pgexpr()->Pgroup()->PstatsRecursiveDerive(
m_mp, m_mp, CReqdPropRelational::GetReqdRelationalProps(m_prp),
stats_ctxt);
pstatsRoot->AddRef();
}
else
{
/ otherwise, derive stats using root operator
pstatsRoot = popLogical->PstatsDerive(m_mp, *this, stats_ctxt);
}
GPOS_ASSERT(nullptr != pstatsRoot);
m_pstats = pstatsRoot;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::DeriveStats
/
/ @doc:
/ Recursive stat derivation
/
/---------------------------------------------------------------------------
void
CExpressionHandle::DeriveStats(IStatisticsArray *stats_ctxt,
BOOL fComputeRootStats)
{
GPOS_ASSERT(nullptr != stats_ctxt);
GPOS_ASSERT(nullptr == m_pdrgpstat);
GPOS_ASSERT(nullptr == m_pstats);
GPOS_ASSERT(nullptr != m_pdrgprp);
/ copy input context
IStatisticsArray *pdrgpstatCurrentCtxt =
GPOS_NEW(m_mp) IStatisticsArray(m_mp);
CUtils::AddRefAppend(pdrgpstatCurrentCtxt, stats_ctxt);
/ create array of children stats
m_pdrgpstat = GPOS_NEW(m_mp) IStatisticsArray(m_mp);
ULONG ulMaxChildRisk = 1;
const ULONG arity = Arity();
for (ULONG ul = 0; ul < arity; ul++)
{
/ create a new context for outer references used by current child
IStatisticsArray *pdrgpstatChildCtxt =
PdrgpstatOuterRefs(pdrgpstatCurrentCtxt, ul);
IStatistics *stats = nullptr;
if (nullptr != Pexpr())
{
/ derive stats recursively on child expression
stats = (*Pexpr())[ul]->PstatsDerive(GetReqdRelationalProps(ul),
pdrgpstatChildCtxt);
}
else
{
/ derive stats recursively on child group
stats = (*Pgexpr())[ul]->PstatsRecursiveDerive(
m_mp, m_mp, GetReqdRelationalProps(ul), pdrgpstatChildCtxt);
}
GPOS_ASSERT(nullptr != stats);
/ add child stat to current context
stats->AddRef();
pdrgpstatCurrentCtxt->Append(stats);
pdrgpstatChildCtxt->Release();
/ add child stat to children stat array
stats->AddRef();
m_pdrgpstat->Append(stats);
if (stats->StatsEstimationRisk() > ulMaxChildRisk)
{
ulMaxChildRisk = stats->StatsEstimationRisk();
}
}
if (fComputeRootStats)
{
/ call stat derivation on operator to compute local stats
GPOS_ASSERT(nullptr == m_pstats);
DeriveRootStats(stats_ctxt);
GPOS_ASSERT(nullptr != m_pstats);
CLogical *popLogical = CLogical::PopConvert(Pop());
ULONG risk = ulMaxChildRisk;
if (CStatisticsUtils::IncreasesRisk(popLogical))
{
++risk;
}
m_pstats->SetStatsEstimationRisk(risk);
}
/ clean up current stat context
pdrgpstatCurrentCtxt->Release();
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::DeriveCostContextStats
/
/ @doc:
/ Stats derivation based on required plan properties
/
/---------------------------------------------------------------------------
void
CExpressionHandle::DeriveCostContextStats()
{
GPOS_ASSERT(nullptr != m_pcc);
GPOS_ASSERT(nullptr == m_pcc->Pstats());
/ copy group properties and stats
CopyStats();
if (nullptr != m_pstats && !m_pcc->FNeedsNewStats())
{
/ there is no need to derive stats,
/ stats are copied from owner group
/ (note that m_pdrgpstat may not contain the correct DPE
/ stats of children, but it is used only for deriving the
/ stats, which we don't need to do anymore)
return;
}
CEnfdPartitionPropagation *pepp = m_pcc->Poc()->Prpp()->Pepp();
COperator *pop = Pop();
if (CUtils::FPhysicalScan(pop) &&
CPhysicalScan::PopConvert(pop)->FDynamicScan() &&
pepp->PppsRequired()->ContainsAnyConsumers())
{
/ derive stats on dynamic table scan using stats of part selector
CPhysicalScan *popScan = CPhysicalScan::PopConvert(m_pgexpr->Pop());
IStatistics *pstatsDS = popScan->PstatsDerive(
m_mp, *this, m_pcc->Poc()->Prpp(), m_pcc->Poc()->Pdrgpstat());
if (nullptr == m_pstats || m_pstats->Rows() > pstatsDS->Rows())
{
/ Replace the group stats with our newly derived DPE stats
CRefCount::SafeRelease(m_pstats);
m_pstats = pstatsDS;
}
else
{
/ Eliminating partitions can't possibly increase the row count. If the row
/ count is higher, that's likely due to some heuristics in the estimation.
/ If the row count is the same, there is no need to use DPE stats.
pstatsDS->Release();
}
return;
}
/ release current stats since we will derive new stats
CRefCount::SafeRelease(m_pstats);
m_pstats = nullptr;
/ load stats from child cost context(s) -- these may be different from child groups stats
CRefCount::SafeRelease(m_pdrgpstat);
m_pdrgpstat = nullptr;
m_pdrgpstat = GPOS_NEW(m_mp) IStatisticsArray(m_mp);
const ULONG arity = m_pcc->Pdrgpoc()->Size();
for (ULONG ul = 0; ul < arity; ul++)
{
COptimizationContext *pocChild = (*m_pcc->Pdrgpoc())[ul];
CCostContext *pccChild = pocChild->PccBest();
GPOS_ASSERT(nullptr != pccChild);
GPOS_ASSERT(nullptr != pccChild->Pstats());
pccChild->Pstats()->AddRef();
m_pdrgpstat->Append(pccChild->Pstats());
}
if (CPhysical::PopConvert(m_pgexpr->Pop())->FPassThruStats())
{
GPOS_ASSERT(1 == m_pdrgpstat->Size());
/ copy stats from first child
(*m_pdrgpstat)[0]->AddRef();
m_pstats = (*m_pdrgpstat)[0];
return;
}
/ derive stats using the best logical expression with the same children as attached physical operator
CGroupExpression *pgexprForStats = m_pcc->PgexprForStats();
GPOS_ASSERT(nullptr != pgexprForStats);
CExpressionHandle exprhdl(m_mp);
exprhdl.Attach(pgexprForStats);
exprhdl.DeriveProps(nullptr /*pdpctxt*/);
m_pdrgpstat->AddRef();
exprhdl.m_pdrgpstat = m_pdrgpstat;
exprhdl.ComputeReqdProps(m_pcc->Poc()->GetReqdRelationalProps(),
0 /*ulOptReq*/);
GPOS_ASSERT(nullptr == exprhdl.m_pstats);
IStatistics *stats = m_pgexpr->Pgroup()->PstatsCompute(
m_pcc->Poc(), exprhdl, pgexprForStats);
/ copy stats to main handle
GPOS_ASSERT(nullptr == m_pstats);
GPOS_ASSERT(nullptr != stats);
stats->AddRef();
m_pstats = stats;
GPOS_ASSERT(m_pstats != nullptr);
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::DeriveStats
/
/ @doc:
/ CheckState derivation using given properties and context
/
/---------------------------------------------------------------------------
void
CExpressionHandle::DeriveStats(CMemoryPool *pmpLocal, CMemoryPool *pmpGlobal,
CReqdPropRelational *prprel,
IStatisticsArray *stats_ctxt) const
{
CReqdPropRelational *prprelNew = prprel;
if (nullptr == prprelNew)
{
/ create empty property container
CColRefSet *pcrs = GPOS_NEW(pmpGlobal) CColRefSet(pmpGlobal);
prprelNew = GPOS_NEW(pmpGlobal) CReqdPropRelational(pcrs);
}
else
{
prprelNew->AddRef();
}
IStatisticsArray *pdrgpstatCtxtNew = stats_ctxt;
if (nullptr == stats_ctxt)
{
/ create empty context
pdrgpstatCtxtNew = GPOS_NEW(pmpGlobal) IStatisticsArray(pmpGlobal);
}
else
{
pdrgpstatCtxtNew->AddRef();
}
if (nullptr != Pgexpr())
{
(void) Pgexpr()->Pgroup()->PstatsRecursiveDerive(
pmpLocal, pmpGlobal, prprelNew, pdrgpstatCtxtNew);
}
else
{
GPOS_ASSERT(nullptr != Pexpr());
(void) Pexpr()->PstatsDerive(prprelNew, pdrgpstatCtxtNew);
}
prprelNew->Release();
pdrgpstatCtxtNew->Release();
}
/ Derive the properties of the plan carried by attached cost context.
/ Note that this re-derives the plan properties, instead of using those
/ present in the gexpr, for cost contexts only and under the default
/ CDrvdPropCtxtPlan.
/ On the other hand, the properties in the gexpr may have been derived in
/ other non-default contexts (e.g with cte info).
void
CExpressionHandle::DerivePlanPropsForCostContext()
{
GPOS_ASSERT(nullptr != m_pcc);
GPOS_ASSERT(nullptr != m_pgexpr);
GPOS_CHECK_ABORT;
CDrvdPropCtxtPlan *pdpctxtplan = GPOS_NEW(m_mp) CDrvdPropCtxtPlan(m_mp);
CopyStats();
COperator *pop = m_pgexpr->Pop();
if (COperator::EopPhysicalCTEConsumer == pop->Eopid())
{
/ copy producer plan properties to passed derived plan properties context
ULONG ulCTEId = CPhysicalCTEConsumer::PopConvert(pop)->UlCTEId();
CDrvdPropPlan *pdpplan =
m_pcc->Poc()->Prpp()->Pcter()->Pdpplan(ulCTEId);
if (nullptr != pdpplan)
{
pdpctxtplan->CopyCTEProducerProps(pdpplan, ulCTEId);
}
}
/ create/derive local properties
m_pdpplan = Pop()->PdpCreate(m_mp);
m_pdpplan->Derive(m_mp, *this, pdpctxtplan);
pdpctxtplan->Release();
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::InitReqdProps
/
/ @doc:
/ Init required properties containers
/
/
/---------------------------------------------------------------------------
void
CExpressionHandle::InitReqdProps(CReqdProp *prpInput)
{
GPOS_ASSERT(nullptr != prpInput);
GPOS_ASSERT(nullptr == m_prp);
GPOS_ASSERT(nullptr == m_pdrgprp);
/ set required properties of attached expr/gexpr
m_prp = prpInput;
m_prp->AddRef();
/ compute required properties of children
m_pdrgprp = GPOS_NEW(m_mp) CReqdPropArray(m_mp);
/ initialize array with input requirements,
/ the initial requirements are only place holders in the array
/ and they are replaced when computing the requirements of each child
const ULONG arity = Arity();
for (ULONG ul = 0; ul < arity; ul++)
{
m_prp->AddRef();
m_pdrgprp->Append(m_prp);
}
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::ComputeChildReqdProps
/
/ @doc:
/ Compute required properties of the n-th child
/
/
/---------------------------------------------------------------------------
void
CExpressionHandle::ComputeChildReqdProps(ULONG child_index,
CDrvdPropArray *pdrgpdpCtxt,
ULONG ulOptReq)
{
GPOS_ASSERT(nullptr != m_prp);
GPOS_ASSERT(nullptr != m_pdrgprp);
GPOS_ASSERT(m_pdrgprp->Size() == Arity());
GPOS_ASSERT(child_index < m_pdrgprp->Size() &&
"uninitialized required child properties");
GPOS_CHECK_ABORT;
CReqdProp *prp = m_prp;
if (FScalarChild(child_index))
{
/ use local reqd properties to fill scalar child entry in children array
prp->AddRef();
}
else
{
/ compute required properties based on child type
prp = Pop()->PrpCreate(m_mp);
prp->Compute(m_mp, *this, m_prp, child_index, pdrgpdpCtxt, ulOptReq);
}
/ replace required properties of given child
m_pdrgprp->Replace(child_index, prp);
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::CopyChildReqdProps
/
/ @doc:
/ Copy required properties of the n-th child
/
/
/---------------------------------------------------------------------------
void
CExpressionHandle::CopyChildReqdProps(ULONG child_index, CReqdProp *prp)
{
GPOS_ASSERT(nullptr != prp);
GPOS_ASSERT(nullptr != m_pdrgprp);
GPOS_ASSERT(m_pdrgprp->Size() == Arity());
GPOS_ASSERT(child_index < m_pdrgprp->Size() &&
"uninitialized required child properties");
m_pdrgprp->Replace(child_index, prp);
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::ComputeChildReqdCols
/
/ @doc:
/ Compute required columns of the n-th child
/
/
/---------------------------------------------------------------------------
void
CExpressionHandle::ComputeChildReqdCols(ULONG child_index,
CDrvdPropArray *pdrgpdpCtxt)
{
GPOS_ASSERT(nullptr != m_prp);
GPOS_ASSERT(nullptr != m_pdrgprp);
GPOS_ASSERT(m_pdrgprp->Size() == Arity());
GPOS_ASSERT(child_index < m_pdrgprp->Size() &&
"uninitialized required child properties");
CReqdProp *prp = m_prp;
if (FScalarChild(child_index))
{
/ use local reqd properties to fill scalar child entry in children array
prp->AddRef();
}
else
{
/ compute required columns
prp = Pop()->PrpCreate(m_mp);
CReqdPropPlan::Prpp(prp)->ComputeReqdCols(m_mp, *this, m_prp,
child_index, pdrgpdpCtxt);
}
/ replace required properties of given child
m_pdrgprp->Replace(child_index, prp);
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::ComputeReqdProps
/
/ @doc:
/ Set required properties of attached expr/gexpr, and compute required
/ properties of all children
/
/---------------------------------------------------------------------------
void
CExpressionHandle::ComputeReqdProps(CReqdProp *prpInput, ULONG ulOptReq)
{
InitReqdProps(prpInput);
const ULONG arity = Arity();
for (ULONG ul = 0; ul < arity; ul++)
{
ComputeChildReqdProps(ul, nullptr /*pdrgpdpCtxt*/, ulOptReq);
}
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::FScalarChild
/
/ @doc:
/ Check if a given child is a scalar expression/group
/
/---------------------------------------------------------------------------
BOOL
CExpressionHandle::FScalarChild(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->Pop()->FScalar();
}
GPOS_ASSERT(nullptr != Pgexpr());
return (*Pgexpr())[child_index]->FScalar();
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::Arity
/
/ @doc:
/ Return number of children of attached expression/group expression
/
/---------------------------------------------------------------------------
ULONG
CExpressionHandle::Arity() const
{
if (nullptr != Pexpr())
{
return Pexpr()->Arity();
}
GPOS_ASSERT(nullptr != Pgexpr());
return Pgexpr()->Arity();
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::UlLastNonScalarChild
/
/ @doc:
/ Return the index of the last non-scalar child. This is only valid if
/ Arity() is greater than 0
/
/---------------------------------------------------------------------------
ULONG
CExpressionHandle::UlLastNonScalarChild() const
{
const ULONG arity = Arity();
if (0 == arity)
{
return gpos::ulong_max;
}
ULONG ulLastNonScalarChild = arity - 1;
while (0 < ulLastNonScalarChild && FScalarChild(ulLastNonScalarChild))
{
ulLastNonScalarChild--;
}
if (!FScalarChild(ulLastNonScalarChild))
{
/ we need to check again that index points to a non-scalar child
/ since operator's children may be all scalar (e.g. index-scan)
return ulLastNonScalarChild;
}
return gpos::ulong_max;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::UlFirstNonScalarChild
/
/ @doc:
/ Return the index of the first non-scalar child. This is only valid if
/ Arity() is greater than 0
/
/---------------------------------------------------------------------------
ULONG
CExpressionHandle::UlFirstNonScalarChild() const
{
const ULONG arity = Arity();
if (0 == arity)
{
return gpos::ulong_max;
}
ULONG ulFirstNonScalarChild = 0;
while (ulFirstNonScalarChild < arity - 1 &&
FScalarChild(ulFirstNonScalarChild))
{
ulFirstNonScalarChild++;
}
if (!FScalarChild(ulFirstNonScalarChild))
{
/ we need to check again that index points to a non-scalar child
/ since operator's children may be all scalar (e.g. index-scan)
return ulFirstNonScalarChild;
}
return gpos::ulong_max;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::UlNonScalarChildren
/
/ @doc:
/ Return number of non-scalar children
/
/---------------------------------------------------------------------------
ULONG
CExpressionHandle::UlNonScalarChildren() const
{
const ULONG arity = Arity();
ULONG ulNonScalarChildren = 0;
for (ULONG ul = 0; ul < arity; ul++)
{
if (!FScalarChild(ul))
{
ulNonScalarChildren++;
}
}
return ulNonScalarChildren;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::GetRelationalProperties
/
/ @doc:
/ Retrieve derived relational props of n-th child;
/ Assumes caller knows what properties to ask for;
/
/---------------------------------------------------------------------------
CDrvdPropRelational *
CExpressionHandle::GetRelationalProperties(ULONG child_index) const
{
if (nullptr != Pexpr())
{
/ handle is used for required property computation
if (Pexpr()->Pop()->FPhysical())
{
/ relational props were copied from memo, return props directly
return (*Pexpr())[child_index]->GetDrvdPropRelational();
}
/ return props after calling derivation function
return CDrvdPropRelational::GetRelationalProperties(
(*Pexpr())[child_index]->PdpDerive());
}
GPOS_ASSERT(nullptr != m_pcc || nullptr != m_pgexpr);
/ handle is used for deriving plan properties, get relational props from child group
CDrvdPropRelational *drvdProps =
CDrvdPropRelational::GetRelationalProperties(
(*Pgexpr())[child_index]->Pdp());
GPOS_ASSERT(drvdProps->IsComplete());
return drvdProps;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::GetRelationalProperties
/
/ @doc:
/ Retrieve relational properties of attached expr/gexpr;
/
/---------------------------------------------------------------------------
CDrvdPropRelational *
CExpressionHandle::GetRelationalProperties() const
{
if (nullptr != Pexpr())
{
if (Pexpr()->Pop()->FPhysical())
{
/ relational props were copied from memo, return props directly
CDrvdPropRelational *drvdProps = Pexpr()->GetDrvdPropRelational();
GPOS_ASSERT(drvdProps->IsComplete());
return drvdProps;
}
/ return props after calling derivation function
return CDrvdPropRelational::GetRelationalProperties(
Pexpr()->PdpDerive());
}
GPOS_ASSERT(nullptr != m_pcc || nullptr != m_pgexpr);
/ get relational props from group
CDrvdPropRelational *drvdProps =
CDrvdPropRelational::GetRelationalProperties(Pgexpr()->Pgroup()->Pdp());
GPOS_ASSERT(drvdProps->IsComplete());
return drvdProps;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::Pstats
/
/ @doc:
/ Return derived stats of n-th child
/
/---------------------------------------------------------------------------
IStatistics *
CExpressionHandle::Pstats(ULONG child_index) const
{
GPOS_ASSERT(child_index < m_pdrgpstat->Size());
return (*m_pdrgpstat)[child_index];
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::Pdpplan
/
/ @doc:
/ Retrieve derived plan props of n-th child;
/ Assumes caller knows what properties to ask for;
/
/---------------------------------------------------------------------------
CDrvdPropPlan *
CExpressionHandle::Pdpplan(ULONG child_index) const
{
if (nullptr != m_pexpr)
{
return CDrvdPropPlan::Pdpplan(
(*m_pexpr)[child_index]->Pdp(CDrvdProp::EptPlan));
}
GPOS_ASSERT(nullptr != m_pcc || nullptr != m_pgexpr);
COptimizationContext *pocChild = (*m_pcc->Pdrgpoc())[child_index];
CDrvdPropPlan *pdpplan = pocChild->PccBest()->Pdpplan();
return pdpplan;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::GetDrvdScalarProps
/
/ @doc:
/ Retrieve derived scalar props of n-th child;
/ Assumes caller knows what properties to ask for;
/
/---------------------------------------------------------------------------
CDrvdPropScalar *
CExpressionHandle::GetDrvdScalarProps(ULONG child_index) const
{
if (nullptr != Pexpr())
{
/ handle is used for required property computation
return CDrvdPropScalar::GetDrvdScalarProps(
(*Pexpr())[child_index]->PdpDerive());
}
GPOS_ASSERT(nullptr != m_pcc || nullptr != m_pgexpr);
/ handle is used for deriving plan properties, get scalar props from child group
return CDrvdPropScalar::GetDrvdScalarProps((*Pgexpr())[child_index]->Pdp());
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::GetReqdRelationalProps
/
/ @doc:
/ Retrieve required relational props of n-th child;
/ Assumes caller knows what properties to ask for;
/
/---------------------------------------------------------------------------
CReqdPropRelational *
CExpressionHandle::GetReqdRelationalProps(ULONG child_index) const
{
GPOS_ASSERT(child_index < m_pdrgprp->Size());
CReqdProp *prp = (*m_pdrgprp)[child_index];
GPOS_ASSERT(prp->FRelational() && "Unexpected property type");
return CReqdPropRelational::GetReqdRelationalProps(prp);
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::Prpp
/
/ @doc:
/ Retrieve required relational props of n-th child;
/ Assumes caller knows what properties to ask for;
/
/---------------------------------------------------------------------------
CReqdPropPlan *
CExpressionHandle::Prpp(ULONG child_index) const
{
GPOS_ASSERT(child_index < m_pdrgprp->Size());
CReqdProp *prp = (*m_pdrgprp)[child_index];
GPOS_ASSERT(prp->FPlan() && "Unexpected property type");
return CReqdPropPlan::Prpp(prp);
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::Pop
/
/ @doc:
/ Get operator from handle
/
/---------------------------------------------------------------------------
COperator *
CExpressionHandle::Pop() const
{
if (nullptr != m_pexpr)
{
GPOS_ASSERT(nullptr == m_pgexpr);
return m_pexpr->Pop();
}
if (nullptr != m_pgexpr)
{
return m_pgexpr->Pop();
}
GPOS_ASSERT(!"Handle was not attached properly");
return nullptr;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::Pop
/
/ @doc:
/ Get child operator from handle
/
/---------------------------------------------------------------------------
COperator *
CExpressionHandle::Pop(ULONG child_index) const
{
GPOS_ASSERT(child_index < Arity());
if (nullptr != m_pexpr)
{
GPOS_ASSERT(nullptr == m_pgexpr);
return (*m_pexpr)[child_index]->Pop();
}
if (nullptr != m_pcc)
{
COptimizationContext *pocChild = (*m_pcc->Pdrgpoc())[child_index];
GPOS_ASSERT(nullptr != pocChild);
CCostContext *pccChild = pocChild->PccBest();
GPOS_ASSERT(nullptr != pccChild);
return pccChild->Pgexpr()->Pop();
}
return nullptr;
}
COperator *
CExpressionHandle::PopGrandchild(ULONG child_index, ULONG grandchild_index,
CCostContext **grandchildContext) const
{
GPOS_ASSERT(child_index < Arity());
if (grandchildContext)
{
*grandchildContext = nullptr;
}
if (nullptr != m_pexpr)
{
GPOS_ASSERT(nullptr == m_pcc);
CExpression *childExpr = (*m_pexpr)[child_index];
if (nullptr != childExpr)
{
return (*childExpr)[grandchild_index]->Pop();
}
return nullptr;
}
if (nullptr != m_pcc)
{
COptimizationContext *pocChild = (*m_pcc->Pdrgpoc())[child_index];
GPOS_ASSERT(nullptr != pocChild);
CCostContext *pccChild = pocChild->PccBest();
GPOS_ASSERT(nullptr != pccChild);
COptimizationContext *pocGrandchild =
(*pccChild->Pdrgpoc())[grandchild_index];
if (nullptr != pocGrandchild)
{
CCostContext *pccgrandchild = pocGrandchild->PccBest();
if (grandchildContext)
{
*grandchildContext = pccgrandchild;
}
return pccgrandchild->Pgexpr()->Pop();
}
}
return nullptr;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::DeriveProducerStats
/
/ @doc:
/ If the child (child_index) is a CTE consumer, then derive is corresponding
/ producer statistics.
/
/---------------------------------------------------------------------------
void
CExpressionHandle::DeriveProducerStats(ULONG child_index,
CColRefSet *pcrsStats) const
{
/ check to see if there are any CTE consumers in the group whose properties have
/ to be pushed to its corresponding CTE producer
CGroupExpression *pgexpr = Pgexpr();
if (nullptr != pgexpr)
{
CGroup *pgroupChild = (*pgexpr)[child_index];
if (pgroupChild->FHasAnyCTEConsumer())
{
CGroupExpression *pgexprCTEConsumer =
pgroupChild->PgexprAnyCTEConsumer();
CLogicalCTEConsumer *popConsumer =
CLogicalCTEConsumer::PopConvert(pgexprCTEConsumer->Pop());
COptCtxt::PoctxtFromTLS()->Pcteinfo()->DeriveProducerStats(
popConsumer, pcrsStats);
}
return;
}
/ statistics are also derived on expressions representing the producer that may have
/ multiple CTE consumers. We should ensure that their properties are to pushed to their
/ corresponding CTE producer
CExpression *pexpr = Pexpr();
if (nullptr != pexpr)
{
CExpression *pexprChild = (*pexpr)[child_index];
if (COperator::EopLogicalCTEConsumer == pexprChild->Pop()->Eopid())
{
CLogicalCTEConsumer *popConsumer =
CLogicalCTEConsumer::PopConvert(pexprChild->Pop());
COptCtxt::PoctxtFromTLS()->Pcteinfo()->DeriveProducerStats(
popConsumer, pcrsStats);
}
}
}
/---------------------------------------------------------------------------
/ CExpressionHandle::PexprScalarRepChild
/
/ Get a representative (inexact) scalar child at given index. Subqueries
/ in the child are replaced by a TRUE or NULL constant. Use this method
/ where exactness is not required, e. g. for statistics derivation,
/ costing, or for heuristics.
/
/---------------------------------------------------------------------------
CExpression *
CExpressionHandle::PexprScalarRepChild(ULONG child_index) const
{
GPOS_ASSERT(child_index < Arity());
if (nullptr != m_pgexpr)
{
/ access scalar expression cached on the child scalar group
GPOS_ASSERT((*m_pgexpr)[child_index]->FScalar());
CExpression *pexprScalar = (*m_pgexpr)[child_index]->PexprScalarRep();
GPOS_ASSERT(nullptr != pexprScalar);
return pexprScalar;
}
if (nullptr != m_pexpr && nullptr != (*m_pexpr)[child_index]->Pgexpr())
{
/ if the expression does not come from a group, but its child does then
/ get the scalar child from that group
CGroupExpression *pgexpr = (*m_pexpr)[child_index]->Pgexpr();
CExpression *pexprScalar = pgexpr->Pgroup()->PexprScalarRep();
GPOS_ASSERT(nullptr != pexprScalar);
return pexprScalar;
}
/ access scalar expression from the child expression node
GPOS_ASSERT((*m_pexpr)[child_index]->Pop()->FScalar());
return (*m_pexpr)[child_index];
}
/---------------------------------------------------------------------------
/ CExpressionHandle::PexprScalarRep
/
/ Get a representative scalar expression attached to handle,
/ return NULL if handle is not attached to a scalar expression.
/ Note that this may be inexact if handle is attached to a
/ CGroupExpression - subqueries will be replaced by a TRUE or NULL
/ constant. Use this method where exactness is not required, e. g.
/ for statistics derivation, costing, or for heuristics.
/
/---------------------------------------------------------------------------
CExpression *
CExpressionHandle::PexprScalarRep() const
{
if (!Pop()->FScalar())
{
return nullptr;
}
if (nullptr != m_pexpr)
{
return m_pexpr;
}
if (nullptr != m_pgexpr)
{
return m_pgexpr->Pgroup()->PexprScalarRep();
}
return nullptr;
}
/ return an exact scalar child at given index or return null if not possible
/ (use this where exactness is required, e.g. for constraint derivation)
CExpression *
CExpressionHandle::PexprScalarExactChild(ULONG child_index,
BOOL error_on_null_return) const
{
CExpression *result_expr = nullptr;
if (nullptr != m_pgexpr && !(*m_pgexpr)[child_index]->FScalarRepIsExact())
{
result_expr = nullptr;
}
else if (nullptr != m_pexpr &&
nullptr != (*m_pexpr)[child_index]->Pgexpr() &&
!((*m_pexpr)[child_index]
->Pgexpr()
->Pgroup()
->FScalarRepIsExact()))
{
/ the expression does not come from a group, but its child does and
/ the child group does not have an exact expression
result_expr = nullptr;
}
else
{
result_expr = PexprScalarRepChild(child_index);
}
if (nullptr == result_expr && error_on_null_return)
{
GPOS_RAISE(CException::ExmaInvalid, CException::ExmiInvalid,
GPOS_WSZ_LIT("Generated invalid plan with subquery"));
}
return result_expr;
}
/ return an exact scalar expression attached to handle or null if not possible
/ (use this where exactness is required, e.g. for constraint derivation)
CExpression *
CExpressionHandle::PexprScalarExact() const
{
if (nullptr != m_pgexpr && !m_pgexpr->Pgroup()->FScalarRepIsExact())
{
return nullptr;
}
return PexprScalarRep();
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::PfpChild
/
/ @doc:
/ Retrieve derived function props of n-th child;
/
/---------------------------------------------------------------------------
CFunctionProp *
CExpressionHandle::PfpChild(ULONG child_index) const
{
if (FScalarChild(child_index))
{
return DeriveScalarFunctionProperties(child_index);
}
return this->DeriveFunctionProperties(child_index);
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::FChildrenHaveVolatileFuncScan
/
/ @doc:
/ Check whether an expression's children have a volatile function scan
/
/---------------------------------------------------------------------------
BOOL
CExpressionHandle::FChildrenHaveVolatileFuncScan() const
{
const ULONG arity = Arity();
for (ULONG ul = 0; ul < arity; ul++)
{
if (PfpChild(ul)->FHasVolatileFunctionScan())
{
return true;
}
}
return false;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::FChildrenHaveVolatileFunc
/
/ @doc:
/ Check whether an expression's children have a volatile function
/
/---------------------------------------------------------------------------
BOOL
CExpressionHandle::FChildrenHaveVolatileFunc() const
{
const ULONG arity = Arity();
for (ULONG ul = 0; ul < arity; ul++)
{
if (PfpChild(ul)->Efs() == IMDFunction::EfsVolatile)
{
return true;
}
}
return false;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::UlFirstOptimizedChildIndex
/
/ @doc:
/ Return the index of first child to be optimized
/
/---------------------------------------------------------------------------
ULONG
CExpressionHandle::UlFirstOptimizedChildIndex() const
{
const ULONG arity = Arity();
GPOS_ASSERT(0 < arity);
CPhysical::EChildExecOrder eceo = CPhysical::PopConvert(Pop())->Eceo();
if (CPhysical::EceoRightToLeft == eceo)
{
return arity - 1;
}
GPOS_ASSERT(CPhysical::EceoLeftToRight == eceo);
return 0;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::UlLastOptimizedChildIndex
/
/ @doc:
/ Return the index of last child to be optimized
/
/---------------------------------------------------------------------------
ULONG
CExpressionHandle::UlLastOptimizedChildIndex() const
{
const ULONG arity = Arity();
GPOS_ASSERT(0 < arity);
CPhysical::EChildExecOrder eceo = CPhysical::PopConvert(Pop())->Eceo();
if (CPhysical::EceoRightToLeft == eceo)
{
return 0;
}
GPOS_ASSERT(CPhysical::EceoLeftToRight == eceo);
return arity - 1;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::UlNextOptimizedChildIndex
/
/ @doc:
/ Return the index of child to be optimized next to the given child,
/ return gpos::ulong_max if there is no next child index
/
/
/---------------------------------------------------------------------------
ULONG
CExpressionHandle::UlNextOptimizedChildIndex(ULONG child_index) const
{
CPhysical::EChildExecOrder eceo = CPhysical::PopConvert(Pop())->Eceo();
ULONG ulNextChildIndex = gpos::ulong_max;
if (CPhysical::EceoRightToLeft == eceo)
{
if (0 < child_index)
{
ulNextChildIndex = child_index - 1;
}
}
else
{
GPOS_ASSERT(CPhysical::EceoLeftToRight == eceo);
if (Arity() - 1 > child_index)
{
ulNextChildIndex = child_index + 1;
}
}
return ulNextChildIndex;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::UlPreviousOptimizedChildIndex
/
/ @doc:
/ Return the index of child optimized before the given child,
/ return gpos::ulong_max if there is no previous child index
/
/
/---------------------------------------------------------------------------
ULONG
CExpressionHandle::UlPreviousOptimizedChildIndex(ULONG child_index) const
{
CPhysical::EChildExecOrder eceo = CPhysical::PopConvert(Pop())->Eceo();
ULONG ulPrevChildIndex = gpos::ulong_max;
if (CPhysical::EceoRightToLeft == eceo)
{
if (Arity() - 1 > child_index)
{
ulPrevChildIndex = child_index + 1;
}
}
else
{
GPOS_ASSERT(CPhysical::EceoLeftToRight == eceo);
if (0 < child_index)
{
ulPrevChildIndex = child_index - 1;
}
}
return ulPrevChildIndex;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::FNextChildIndex
/
/ @doc:
/ Get next child index based on child optimization order, return
/ true if such index could be found
/
/---------------------------------------------------------------------------
BOOL
CExpressionHandle::FNextChildIndex(ULONG *pulChildIndex) const
{
GPOS_ASSERT(nullptr != pulChildIndex);
const ULONG arity = Arity();
if (0 == arity)
{
/ operator does not have children
return false;
}
ULONG ulNextChildIndex = UlNextOptimizedChildIndex(*pulChildIndex);
if (gpos::ulong_max == ulNextChildIndex)
{
return false;
}
*pulChildIndex = ulNextChildIndex;
return true;
}
/---------------------------------------------------------------------------
/ @function:
/ CExpressionHandle::PcrsUsedColumns
/
/ @doc:
/ Return the columns used by a logical operator and all its scalar children
/
/---------------------------------------------------------------------------
CColRefSet *
CExpressionHandle::PcrsUsedColumns(CMemoryPool *mp) const
{
COperator *pop = Pop();
GPOS_ASSERT(pop->FLogical());
CColRefSet *pcrs = GPOS_NEW(mp) CColRefSet(mp);
/ get columns used by the operator itself
pcrs->Include(CLogical::PopConvert(pop)->PcrsLocalUsed());
/ get columns used by the scalar children
const ULONG arity = Arity();
for (ULONG ul = 0; ul < arity; ul++)
{
if (FScalarChild(ul))
{
pcrs->Include(DeriveUsedColumns(ul));
}
}
return pcrs;
}
CDrvdProp *
CExpressionHandle::Pdp() const
{
if (nullptr != m_pcc)
{
GPOS_ASSERT(m_pdpplan != nullptr);
return m_pdpplan;
}
if (nullptr != Pexpr())
{
return Pexpr()->Pdp(Pexpr()->Ept());
}
GPOS_ASSERT(nullptr != Pgexpr());
return Pgexpr()->Pgroup()->Pdp();
}
IStatistics *
CExpressionHandle::Pstats()
{
return m_pstats;
}
/ The below functions use on-demand property derivation
/ only if there is an expression associated with the expression handle.
/ If there is only a group expression or a cost context assoicated with the handle,
/ all properties must have already been derived as we can't derive anything.
CColRefSet *
CExpressionHandle::DeriveOuterReferences(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveOuterReferences();
}
return GetRelationalProperties(child_index)->GetOuterReferences();
}
CColRefSet *
CExpressionHandle::DeriveOuterReferences() const
{
if (nullptr != Pexpr())
{
return Pexpr()->DeriveOuterReferences();
}
return GetRelationalProperties()->GetOuterReferences();
}
CColRefSet *
CExpressionHandle::DeriveOutputColumns(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveOutputColumns();
}
return GetRelationalProperties(child_index)->GetOutputColumns();
}
CColRefSet *
CExpressionHandle::DeriveOutputColumns() const
{
if (nullptr != Pexpr())
{
return Pexpr()->DeriveOutputColumns();
}
return GetRelationalProperties()->GetOutputColumns();
}
CColRefSet *
CExpressionHandle::DeriveNotNullColumns(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveNotNullColumns();
}
return GetRelationalProperties(child_index)->GetNotNullColumns();
}
CColRefSet *
CExpressionHandle::DeriveNotNullColumns() const
{
if (nullptr != Pexpr())
{
return Pexpr()->DeriveNotNullColumns();
}
return GetRelationalProperties()->GetNotNullColumns();
}
CMaxCard
CExpressionHandle::DeriveMaxCard(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveMaxCard();
}
return GetRelationalProperties(child_index)->GetMaxCard();
}
CMaxCard
CExpressionHandle::DeriveMaxCard() const
{
if (nullptr != Pexpr())
{
return Pexpr()->DeriveMaxCard();
}
return GetRelationalProperties()->GetMaxCard();
}
CColRefSet *
CExpressionHandle::DeriveCorrelatedApplyColumns(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveCorrelatedApplyColumns();
}
return GetRelationalProperties(child_index)->GetCorrelatedApplyColumns();
}
CColRefSet *
CExpressionHandle::DeriveCorrelatedApplyColumns() const
{
if (nullptr != Pexpr())
{
return Pexpr()->DeriveCorrelatedApplyColumns();
}
return GetRelationalProperties()->GetCorrelatedApplyColumns();
}
CKeyCollection *
CExpressionHandle::DeriveKeyCollection(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveKeyCollection();
}
return GetRelationalProperties(child_index)->GetKeyCollection();
}
CKeyCollection *
CExpressionHandle::DeriveKeyCollection() const
{
if (nullptr != Pexpr())
{
return Pexpr()->DeriveKeyCollection();
}
return GetRelationalProperties()->GetKeyCollection();
}
CPropConstraint *
CExpressionHandle::DerivePropertyConstraint(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DerivePropertyConstraint();
}
return GetRelationalProperties(child_index)->GetPropertyConstraint();
}
CPropConstraint *
CExpressionHandle::DerivePropertyConstraint() const
{
if (nullptr != Pexpr())
{
return Pexpr()->DerivePropertyConstraint();
}
return GetRelationalProperties()->GetPropertyConstraint();
}
ULONG
CExpressionHandle::DeriveJoinDepth(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveJoinDepth();
}
return GetRelationalProperties(child_index)->GetJoinDepth();
}
ULONG
CExpressionHandle::DeriveJoinDepth() const
{
if (nullptr != Pexpr())
{
return Pexpr()->DeriveJoinDepth();
}
return GetRelationalProperties()->GetJoinDepth();
}
CFunctionProp *
CExpressionHandle::DeriveFunctionProperties(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveFunctionProperties();
}
return GetRelationalProperties(child_index)->GetFunctionProperties();
}
CFunctionProp *
CExpressionHandle::DeriveFunctionProperties() const
{
if (nullptr != Pexpr())
{
return Pexpr()->DeriveFunctionProperties();
}
return GetRelationalProperties()->GetFunctionProperties();
}
CFunctionalDependencyArray *
CExpressionHandle::Pdrgpfd(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveFunctionalDependencies();
}
return GetRelationalProperties(child_index)->GetFunctionalDependencies();
}
CFunctionalDependencyArray *
CExpressionHandle::Pdrgpfd() const
{
if (nullptr != Pexpr())
{
return Pexpr()->DeriveFunctionalDependencies();
}
return GetRelationalProperties()->GetFunctionalDependencies();
}
CPartInfo *
CExpressionHandle::DerivePartitionInfo(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DerivePartitionInfo();
}
return GetRelationalProperties(child_index)->GetPartitionInfo();
}
CPartInfo *
CExpressionHandle::DerivePartitionInfo() const
{
if (nullptr != Pexpr())
{
return Pexpr()->DerivePartitionInfo();
}
return GetRelationalProperties()->GetPartitionInfo();
}
CTableDescriptor *
CExpressionHandle::DeriveTableDescriptor() const
{
if (nullptr != Pexpr())
{
return Pexpr()->DeriveTableDescriptor();
}
return GetRelationalProperties()->GetTableDescriptor();
}
CTableDescriptor *
CExpressionHandle::DeriveTableDescriptor(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveTableDescriptor();
}
return GetRelationalProperties(child_index)->GetTableDescriptor();
}
/ Scalar property accessors
CColRefSet *
CExpressionHandle::DeriveDefinedColumns(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveDefinedColumns();
}
return GetDrvdScalarProps(child_index)->GetDefinedColumns();
}
CColRefSet *
CExpressionHandle::DeriveUsedColumns(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveUsedColumns();
}
return GetDrvdScalarProps(child_index)->GetUsedColumns();
}
CColRefSet *
CExpressionHandle::DeriveSetReturningFunctionColumns(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveSetReturningFunctionColumns();
}
return GetDrvdScalarProps(child_index)->GetSetReturningFunctionColumns();
}
BOOL
CExpressionHandle::DeriveHasSubquery(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveHasSubquery();
}
return GetDrvdScalarProps(child_index)->HasSubquery();
}
CPartInfo *
CExpressionHandle::DeriveScalarPartitionInfo(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveScalarPartitionInfo();
}
return GetDrvdScalarProps(child_index)->GetPartitionInfo();
}
CFunctionProp *
CExpressionHandle::DeriveScalarFunctionProperties(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveScalarFunctionProperties();
}
return GetDrvdScalarProps(child_index)->GetFunctionProperties();
}
BOOL
CExpressionHandle::DeriveHasNonScalarFunction(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveHasNonScalarFunction();
}
return GetDrvdScalarProps(child_index)->HasNonScalarFunction();
}
ULONG
CExpressionHandle::DeriveTotalDistinctAggs(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveTotalDistinctAggs();
}
return GetDrvdScalarProps(child_index)->GetTotalDistinctAggs();
}
BOOL
CExpressionHandle::DeriveHasMultipleDistinctAggs(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveHasMultipleDistinctAggs();
}
return GetDrvdScalarProps(child_index)->HasMultipleDistinctAggs();
}
BOOL
CExpressionHandle::DeriveHasScalarArrayCmp(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveHasScalarArrayCmp();
}
return GetDrvdScalarProps(child_index)->HasScalarArrayCmp();
}
BOOL
CExpressionHandle::DeriveHasScalarFuncProject(ULONG child_index) const
{
if (nullptr != Pexpr())
{
return (*Pexpr())[child_index]->DeriveHasScalarFuncProject();
}
return GetDrvdScalarProps(child_index)->HasScalarFuncProject();
}
/ EOF
相关信息
相关文章
greenplumn CExpressionFactorizer 源码
greenplumn CExpressionPreprocessor 源码
greenplumn CExpressionUtils 源码
greenplumn CHashedDistributions 源码