//---------------------------------------------------------------------------
// @function:
// CLogicalSetOp::PpartinfoDerive
//
// @doc:
// Derive partition consumer info
//
//---------------------------------------------------------------------------
CPartInfo *
CLogicalSetOp::PpartinfoDerive
(
IMemoryPool *pmp,
CExpressionHandle &exprhdl
)
const
{
const ULONG ulArity = exprhdl.UlArity();
GPOS_ASSERT(0 < ulArity);
// start with the part info of the first child
CPartInfo *ppartinfo = exprhdl.Pdprel(0 /*ulChildIndex*/)->Ppartinfo();
ppartinfo->AddRef();
for (ULONG ul = 1; ul < ulArity; ul++)
{
CPartInfo *ppartinfoChild = exprhdl.Pdprel(ul)->Ppartinfo();
GPOS_ASSERT(NULL != ppartinfoChild);
DrgPcr *pdrgpcrInput = (*m_pdrgpdrgpcrInput)[ul];
GPOS_ASSERT(pdrgpcrInput->UlLength() == m_pdrgpcrOutput->UlLength());
CPartInfo *ppartinfoRemapped = ppartinfoChild->PpartinfoWithRemappedKeys(pmp, pdrgpcrInput, m_pdrgpcrOutput);
CPartInfo *ppartinfoCombined = CPartInfo::PpartinfoCombine(pmp, ppartinfo, ppartinfoRemapped);
ppartinfoRemapped->Release();
ppartinfo->Release();
ppartinfo = ppartinfoCombined;
}
return ppartinfo;
}
//---------------------------------------------------------------------------
// @function:
// CXformGbAgg2StreamAgg::Transform
//
// @doc:
// Actual transformation
//
//---------------------------------------------------------------------------
void
CXformGbAgg2StreamAgg::Transform
(
CXformContext *pxfctxt,
CXformResult *pxfres,
CExpression *pexpr
)
const
{
GPOS_ASSERT(NULL != pxfctxt);
GPOS_ASSERT(FPromising(pxfctxt->Pmp(), this, pexpr));
GPOS_ASSERT(FCheckPattern(pexpr));
CLogicalGbAgg *popAgg = CLogicalGbAgg::PopConvert(pexpr->Pop());
IMemoryPool *pmp = pxfctxt->Pmp();
DrgPcr *pdrgpcr = popAgg->Pdrgpcr();
pdrgpcr->AddRef();
// extract components
CExpression *pexprRel = (*pexpr)[0];
CExpression *pexprScalar = (*pexpr)[1];
// addref children
pexprRel->AddRef();
pexprScalar->AddRef();
DrgPcr *pdrgpcrArgDQA = popAgg->PdrgpcrArgDQA();
if (pdrgpcrArgDQA != NULL && 0 != pdrgpcrArgDQA->UlLength())
{
pdrgpcrArgDQA->AddRef();
}
// create alternative expression
CExpression *pexprAlt =
GPOS_NEW(pmp) CExpression
(
pmp,
GPOS_NEW(pmp) CPhysicalStreamAgg
(
pmp,
pdrgpcr,
popAgg->PdrgpcrMinimal(),
popAgg->Egbaggtype(),
popAgg->FGeneratesDuplicates(),
pdrgpcrArgDQA,
CXformUtils::FMultiStageAgg(pexpr)
),
pexprRel,
pexprScalar
);
// add alternative to transformation result
pxfres->Add(pexprAlt);
}
//---------------------------------------------------------------------------
// @function:
// CPhysicalUnionAll::PdrgpulMap
//
// @doc:
// Map given array of scalar identifier expressions to positions of
// UnionAll input columns in the given child;
// the function returns NULL if no mapping could be constructed
//
//---------------------------------------------------------------------------
DrgPul *
CPhysicalUnionAll::PdrgpulMap
(
IMemoryPool *pmp,
DrgPexpr *pdrgpexpr,
ULONG ulChildIndex
)
const
{
GPOS_ASSERT(NULL != pdrgpexpr);
DrgPcr *pdrgpcr = (*m_pdrgpdrgpcrInput)[ulChildIndex];
const ULONG ulExprs = pdrgpexpr->UlLength();
const ULONG ulCols = pdrgpcr->UlLength();
DrgPul *pdrgpul = GPOS_NEW(pmp) DrgPul(pmp);
for (ULONG ulExpr = 0; ulExpr < ulExprs; ulExpr++)
{
CExpression *pexpr = (*pdrgpexpr)[ulExpr];
if (COperator::EopScalarIdent != pexpr->Pop()->Eopid())
{
continue;
}
const CColRef *pcr = CScalarIdent::PopConvert(pexpr->Pop())->Pcr();
for (ULONG ulCol = 0; ulCol < ulCols; ulCol++)
{
if ((*pdrgpcr)[ulCol] == pcr)
{
pdrgpul->Append(GPOS_NEW(pmp) ULONG(ulCol));
}
}
}
if (0 == pdrgpul->UlLength())
{
// mapping failed
pdrgpul->Release();
pdrgpul = NULL;
}
return pdrgpul;
}
//---------------------------------------------------------------------------
// @function:
// CDistributionSpecHashed::PdshashedMaximal
//
// @doc:
// Return a hashed distribution on the maximal hashable subset of
// given columns,
// if all columns are not hashable, return NULL
//
//---------------------------------------------------------------------------
CDistributionSpecHashed *
CDistributionSpecHashed::PdshashedMaximal
(
IMemoryPool *pmp,
DrgPcr *pdrgpcr,
BOOL fNullsColocated
)
{
GPOS_ASSERT(NULL != pdrgpcr);
GPOS_ASSERT(0 < pdrgpcr->UlLength());
DrgPcr *pdrgpcrHashable = CUtils::PdrgpcrHashableSubset(pmp, pdrgpcr);
CDistributionSpecHashed *pdshashed = NULL;
if (0 < pdrgpcrHashable->UlLength())
{
DrgPexpr *pdrgpexpr = CUtils::PdrgpexprScalarIdents(pmp, pdrgpcrHashable);
pdshashed = GPOS_NEW(pmp) CDistributionSpecHashed(pdrgpexpr, fNullsColocated);
}
pdrgpcrHashable->Release();
return pdshashed;
}
//---------------------------------------------------------------------------
// @function:
// CPartKeys::PpartkeysCopy
//
// @doc:
// Copy part key into the given memory pool
//
//---------------------------------------------------------------------------
CPartKeys *
CPartKeys::PpartkeysCopy
(
IMemoryPool *pmp
)
{
DrgDrgPcr *pdrgpdrgpcrCopy = GPOS_NEW(pmp) DrgDrgPcr(pmp);
const ULONG ulLength = m_pdrgpdrgpcr->UlLength();
for (ULONG ul = 0; ul < ulLength; ul++)
{
DrgPcr *pdrgpcr = (*m_pdrgpdrgpcr)[ul];
DrgPcr *pdrgpcrCopy = GPOS_NEW(pmp) DrgPcr(pmp);
const ULONG ulCols = pdrgpcr->UlLength();
for (ULONG ulCol = 0; ulCol < ulCols; ulCol++)
{
pdrgpcrCopy->Append((*pdrgpcr)[ulCol]);
}
pdrgpdrgpcrCopy->Append(pdrgpcrCopy);
}
return GPOS_NEW(pmp) CPartKeys(pdrgpdrgpcrCopy);
}
//---------------------------------------------------------------------------
// @function:
// CLogicalUnion::CLogicalUnion
//
// @doc:
// Ctor
//
//---------------------------------------------------------------------------
CLogicalUnion::CLogicalUnion
(
IMemoryPool *pmp,
DrgPcr *pdrgpcrOutput,
DrgDrgPcr *pdrgpdrgpcrInput
)
:
CLogicalSetOp(pmp, pdrgpcrOutput, pdrgpdrgpcrInput)
{
#ifdef GPOS_DEBUG
DrgPcr *pdrgpcrInput = (*pdrgpdrgpcrInput)[0];
const ULONG ulCols = pdrgpcrOutput->UlLength();
GPOS_ASSERT(ulCols == pdrgpcrInput->UlLength());
// Ensure that the output columns are the same as first input
for(ULONG ul = 0; ul < ulCols; ul++)
{
GPOS_ASSERT( (*pdrgpcrOutput)[ul] == (*pdrgpcrInput)[ul]);
}
#endif // GPOS_DEBUG
}
