//---------------------------------------------------------------------------
// @function:
// CXformSelect2PartialDynamicIndexGet::PexprSelectOverDynamicGet
//
// @doc:
// Create a partial dynamic get expression with a select on top
//
//---------------------------------------------------------------------------
CExpression *
CXformSelect2PartialDynamicIndexGet::PexprSelectOverDynamicGet
(
IMemoryPool *pmp,
CLogicalDynamicGet *popGet,
CExpression *pexprScalar,
DrgPcr *pdrgpcrDGet,
CPartConstraint *ppartcnstr
)
{
HMUlCr *phmulcr = CUtils::PhmulcrMapping(pmp, popGet->PdrgpcrOutput(), pdrgpcrDGet);
// construct a partial dynamic get with the negated constraint
CPartConstraint *ppartcnstrPartialDynamicGet = ppartcnstr->PpartcnstrCopyWithRemappedColumns(pmp, phmulcr, true /*fMustExist*/);
CLogicalDynamicGet *popPartialDynamicGet =
(CLogicalDynamicGet *) popGet->PopCopyWithRemappedColumns(pmp, phmulcr, true /*fMustExist*/);
popPartialDynamicGet->SetPartConstraint(ppartcnstrPartialDynamicGet);
popPartialDynamicGet->SetSecondaryScanId(COptCtxt::PoctxtFromTLS()->UlPartIndexNextVal());
popPartialDynamicGet->SetPartial();
CExpression *pexprSelect = GPOS_NEW(pmp) CExpression
(
pmp,
GPOS_NEW(pmp) CLogicalSelect(pmp),
GPOS_NEW(pmp) CExpression(pmp, popPartialDynamicGet),
pexprScalar->PexprCopyWithRemappedColumns(pmp, phmulcr, true /*fMustExist*/)
);
phmulcr->Release();
return pexprSelect;
}
//---------------------------------------------------------------------------
// @function:
// CXformInnerJoin2DynamicBitmapIndexGetApply::Transform
//
// @doc:
// Actual transformation
//
//---------------------------------------------------------------------------
void
CXformInnerJoin2DynamicBitmapIndexGetApply::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 *pexprInner = (*pexpr)[1];
CExpression *pexprScalar = (*pexpr)[2];
GPOS_ASSERT(COperator::EopLogicalDynamicGet == pexprInner->Pop()->Eopid());
CLogicalDynamicGet *popDynamicGet = CLogicalDynamicGet::PopConvert(pexprInner->Pop());
CreateHomogeneousIndexApplyAlternatives
(
pmp,
pexpr->Pop()->UlOpId(),
pexprOuter,
pexprInner,
pexprScalar,
popDynamicGet->Ptabdesc(),
popDynamicGet,
pxfres,
IMDIndex::EmdindBitmap
);
}
//---------------------------------------------------------------------------
// @function:
// CXformInnerJoinWithInnerSelect2PartialDynamicIndexGetApply::Transform
//
// @doc:
// Actual transformation
//
//---------------------------------------------------------------------------
void
CXformInnerJoinWithInnerSelect2PartialDynamicIndexGetApply::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 *pexprInner = (*pexpr)[1];
CExpression *pexprScalar = (*pexpr)[2];
GPOS_ASSERT(COperator::EopLogicalSelect == pexprInner->Pop()->Eopid());
CExpression *pexprGet = (*pexprInner)[0];
GPOS_ASSERT(COperator::EopLogicalDynamicGet == pexprGet->Pop()->Eopid());
CLogicalDynamicGet *popDynamicGet = CLogicalDynamicGet::PopConvert(pexprGet->Pop());
CTableDescriptor *ptabdescInner = popDynamicGet->Ptabdesc();
CExpression *pexprAllPredicates = CPredicateUtils::PexprConjunction(pmp, pexprScalar, (*pexprInner)[1]);
CreatePartialIndexApplyAlternatives
(
pmp,
pexpr->Pop()->UlOpId(),
pexprOuter,
pexprInner,
pexprAllPredicates,
ptabdescInner,
popDynamicGet,
pxfres
);
pexprAllPredicates->Release();
}
//---------------------------------------------------------------------------
// @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:
// 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:
// CXformDynamicGet2DynamicTableScan::Transform
//
// @doc:
// Actual transformation
//
//---------------------------------------------------------------------------
void
CXformDynamicGet2DynamicTableScan::Transform
(
CXformContext *pxfctxt,
CXformResult *pxfres,
CExpression *pexpr
)
const
{
GPOS_ASSERT(NULL != pxfctxt);
GPOS_ASSERT(FPromising(pxfctxt->Pmp(), this, pexpr));
GPOS_ASSERT(FCheckPattern(pexpr));
CLogicalDynamicGet *popGet = CLogicalDynamicGet::PopConvert(pexpr->Pop());
IMemoryPool *pmp = pxfctxt->Pmp();
// create/extract components for alternative
CName *pname = GPOS_NEW(pmp) CName(pmp, popGet->Name());
CTableDescriptor *ptabdesc = popGet->Ptabdesc();
ptabdesc->AddRef();
DrgPcr *pdrgpcrOutput = popGet->PdrgpcrOutput();
GPOS_ASSERT(NULL != pdrgpcrOutput);
pdrgpcrOutput->AddRef();
DrgDrgPcr *pdrgpdrgpcrPart = popGet->PdrgpdrgpcrPart();
pdrgpdrgpcrPart->AddRef();
popGet->Ppartcnstr()->AddRef();
popGet->PpartcnstrRel()->AddRef();
// create alternative expression
CExpression *pexprAlt =
GPOS_NEW(pmp) CExpression
(
pmp,
GPOS_NEW(pmp) CPhysicalDynamicTableScan
(
pmp,
popGet->FPartial(),
pname,
ptabdesc,
popGet->UlOpId(),
popGet->UlScanId(),
pdrgpcrOutput,
pdrgpdrgpcrPart,
popGet->UlSecondaryScanId(),
popGet->Ppartcnstr(),
popGet->PpartcnstrRel()
)
);
// add alternative to transformation result
pxfres->Add(pexprAlt);
}