// LCOV_EXCL_START - cnu
CostScalar
TableDesc::getBaseRowCntIfUniqueJoinCol(const ValueIdSet &joinedCols)
{
// get the joining columns for this table
ValueIdList userColumns;
// get All user columns for this table;
getUserColumnList(userColumns);
ValueIdSet userColumnSet(userColumns);
ValueIdSet joinedColsCopy(joinedCols);
ValueIdSet thisTableJoinCols = joinedColsCopy.intersect(userColumnSet);
if (thisTableJoinCols.isEmpty() )
return csMinusOne;
CostScalar baseRowCount = csMinusOne;
if (thisTableJoinCols.doColumnsConstituteUniqueIndex(this) )
baseRowCount = tableColStats()[0]->getColStats()->getRowcount();
return baseRowCount;
} // TableDesc::getBaseRowCntIfUniqueJoinCol
// PhysSequence::computeHistoryAttributes
//
// Helper function to compute the attribute for the history buffer based
// on the items projected from the child and the computed history items.
// Also, adds the attribute information the the map table.
//
void
PhysSequence::computeHistoryAttributes(Generator *generator,
MapTable *localMapTable,
Attributes **attrs,
const ValueIdSet &historyIds) const
{
// Get a local handle on some of the generator objects.
//
CollHeap *wHeap = generator->wHeap();
// Populate the attribute vector with the flattened list of sequence
// functions and/or sequence function arguments that must be in the
// history row. Add convert nodes for the items that are not sequence
// functions to force them to be moved into the history row.
//
if(NOT historyIds.isEmpty())
{
Int32 i = 0;
ValueId valId;
for (valId = historyIds.init();
historyIds.next(valId);
historyIds.advance(valId))
{
// If this is not a sequence function, then insert a convert
// node.
//
if(!valId.getItemExpr()->isASequenceFunction())
{
// Get a handle on the original expression and erase
// the value ID.
//
ItemExpr *origExpr = valId.getItemExpr();
origExpr->setValueId(NULL_VALUE_ID);
origExpr->markAsUnBound();
// Construct the cast expression with the original expression
// as the child -- must have undone the child value ID to
// avoid recursion later.
//
ItemExpr *castExpr = new(wHeap)
Cast(origExpr, &(valId.getType()));
// Replace the expression for the original value ID and the
// synthesize the types and value ID for the new expression.
//
valId.replaceItemExpr(castExpr);
castExpr->synthTypeAndValueId(TRUE);
}
attrs[i++] = (generator->addMapInfoToThis(localMapTable, valId, 0))->getAttr();
}
}
} // PhysSequence::computeHistoryAttributes
// Is there any column which has a local predicates and no stats
NABoolean TableDesc::isAnyHistWithPredsFakeOrSmallSample(const ValueIdSet &localPreds)
{
// if there are no local predicates return FALSE;
if (localPreds.isEmpty())
return FALSE;
const ColStatDescList & colStatsList = getTableColStats();
// for each predicate, check to see if stats exist
for (ValueId id = localPreds.init();
localPreds.next(id);
localPreds.advance(id))
{
ColStatsSharedPtr colStats = colStatsList.getColStatsPtrForPredicate(id);
if (colStats == NULL)
return FALSE;
if (colStats->isOrigFakeHist() || colStats->isSmallSampleHistogram())
return TRUE;
}
return FALSE;
}
short
PhysSequence::codeGen(Generator *generator)
{
// Get a local handle on some of the generator objects.
//
CollHeap *wHeap = generator->wHeap();
Space *space = generator->getSpace();
ExpGenerator *expGen = generator->getExpGenerator();
MapTable *mapTable = generator->getMapTable();
// Allocate a new map table for this node. This must be done
// before generating the code for my child so that this local
// map table will be sandwiched between the map tables already
// generated and the map tables generated by my offspring.
//
// Only the items available as output from this node will
// be put in the local map table. Before exiting this function, all of
// my offsprings map tables will be removed. Thus, none of the outputs
// from nodes below this node will be visible to nodes above it except
// those placed in the local map table and those that already exist in
// my ancestors map tables. This is the standard mechanism used in the
// generator for managing the access to item expressions.
//
MapTable *localMapTable = generator->appendAtEnd();
// Since this operation doesn't modify the row on the way down the tree,
// go ahead and generate the child subtree. Capture the given composite row
// descriptor and the child's returned TDB and composite row descriptor.
//
ex_cri_desc * givenCriDesc = generator->getCriDesc(Generator::DOWN);
child(0)->codeGen(generator);
ComTdb *childTdb = (ComTdb*)generator->getGenObj();
ex_cri_desc * childCriDesc = generator->getCriDesc(Generator::UP);
ExplainTuple *childExplainTuple = generator->getExplainTuple();
// Make all of my child's outputs map to ATP 1. The child row is only
// accessed in the project expression and it will be the second ATP
// (ATP 1) passed to this expression.
//
localMapTable->setAllAtp(1);
// My returned composite row has an additional tupp.
//
Int32 numberTuples = givenCriDesc->noTuples() + 1;
ex_cri_desc * returnCriDesc
#pragma nowarn(1506) // warning elimination
= new (space) ex_cri_desc(numberTuples, space);
#pragma warn(1506) // warning elimination
// For now, the history buffer row looks just the return row. Later,
// it may be useful to add an additional tupp for sequence function
// itermediates that are not needed above this node -- thus, this
// ATP is kept separate from the returned ATP.
//
const Int32 historyAtp = 0;
const Int32 historyAtpIndex = numberTuples-1;
#pragma nowarn(1506) // warning elimination
ex_cri_desc *historyCriDesc = new (space) ex_cri_desc(numberTuples, space);
#pragma warn(1506) // warning elimination
ExpTupleDesc *historyDesc = 0;
//seperate the read and retur expressions
seperateReadAndReturnItems(wHeap);
// The history buffer consists of items projected directly from the
// child, the root sequence functions, the value arguments of the
// offset functions, and running sequence functions. These elements must
// be materialized in the history buffer in order to be able to compute
// the outputs of this node -- the items projected directly from the child
// (projectValues) and the root sequence functions (sequenceFunctions).
//
// Compute the set of sequence function items that must be materialized
// int the history buffer. -- sequenceItems
//
// Compute the set of items in the history buffer: the union of the
// projected values and the value arguments. -- historyIds
//
// Compute the set of items in the history buffer that are computed:
// the difference between all the elements in the history buffer
// and the projected items. -- computedHistoryIds
//
// KB---will need to return atp with 3 tups only 0,1 and 2
// 2 -->values from history buffer after ther are moved to it
addCheckPartitionChangeExpr(generator, TRUE);
ValueIdSet historyIds;
historyIds += movePartIdsExpr();
historyIds += sequencedColumns();
ValueIdSet outputFromChild = child(0)->getGroupAttr()->getCharacteristicOutputs();
getHistoryAttributes(readSeqFunctions(),outputFromChild, historyIds, TRUE, wHeap);
// Add in the top level sequence functions.
historyIds += readSeqFunctions();
getHistoryAttributes(returnSeqFunctions(),outputFromChild, historyIds, TRUE, wHeap);
// Add in the top level functions.
historyIds += returnSeqFunctions();
// Layout the work tuple format which consists of the projected
// columns and the computed sequence functions. First, compute
// the number of attributes in the tuple.
//
ULng32 numberAttributes
= ((NOT historyIds.isEmpty()) ? historyIds.entries() : 0);
// Allocate an attribute pointer vector from the working heap.
//
Attributes **attrs = new(wHeap) Attributes*[numberAttributes];
// Fill in the attributes vector for the history buffer including
// adding the entries to the map table. Also, compute the value ID
// set for the elements to project from the child row.
//
//??????????re-visit this function??
computeHistoryAttributes(generator,
localMapTable,
attrs,
historyIds);
// Create the tuple descriptor for the history buffer row and
// assign the offsets to the attributes. For now, this layout is
// identical to the returned row. Set the tuple descriptors for
// the return and history rows.
//
ULng32 historyRecLen;
expGen->processAttributes(numberAttributes,
attrs,
ExpTupleDesc::SQLARK_EXPLODED_FORMAT,
historyRecLen,
historyAtp,
historyAtpIndex,
&historyDesc,
ExpTupleDesc::SHORT_FORMAT);
NADELETEBASIC(attrs, wHeap);
#pragma nowarn(1506) // warning elimination
returnCriDesc->setTupleDescriptor(historyAtpIndex, historyDesc);
#pragma warn(1506) // warning elimination
#pragma nowarn(1506) // warning elimination
historyCriDesc->setTupleDescriptor(historyAtpIndex, historyDesc);
#pragma warn(1506) // warning elimination
// If there are any sequence function items, generate the sequence
// function expressions.
//
ex_expr * readSeqExpr = NULL;
if(NOT readSeqFunctions().isEmpty())
{
ValueIdSet seqVals = readSeqFunctions();
seqVals += sequencedColumns();
seqVals += movePartIdsExpr();
expGen->generateSequenceExpression(seqVals,
readSeqExpr);
}
ex_expr *checkPartChangeExpr = NULL;
if (!checkPartitionChangeExpr().isEmpty()) {
ItemExpr * newCheckPartitionChangeTree=
checkPartitionChangeExpr().rebuildExprTree(ITM_AND,TRUE,TRUE);
expGen->generateExpr(newCheckPartitionChangeTree->getValueId(),
ex_expr::exp_SCAN_PRED,
&checkPartChangeExpr);
}
//unsigned long rowLength;
ex_expr * returnExpr = NULL;
if(NOT returnSeqFunctions().isEmpty())
{
expGen->generateSequenceExpression(returnSeqFunctions(),
returnExpr);
}
// Generate expression to evaluate predicate on the output
//
ex_expr *postPred = 0;
if (! selectionPred().isEmpty()) {
ItemExpr * newPredTree =
selectionPred().rebuildExprTree(ITM_AND,TRUE,TRUE);
expGen->generateExpr(newPredTree->getValueId(), ex_expr::exp_SCAN_PRED,
&postPred);
}
// Reset ATP's to zero for parent.
//
localMapTable->setAllAtp(0);
// Generate expression to evaluate the cancel expression
//
ex_expr *cancelExpression = 0;
if (! cancelExpr().isEmpty()) {
ItemExpr * newCancelExprTree =
cancelExpr().rebuildExprTree(ITM_AND,TRUE,TRUE);
expGen->generateExpr(newCancelExprTree->getValueId(), ex_expr::exp_SCAN_PRED,
&cancelExpression);
}
//
// For overflow
//
// ( The following are meaningless if ! unlimitedHistoryRows() )
NABoolean noOverflow =
CmpCommon::getDefault(EXE_BMO_DISABLE_OVERFLOW) == DF_ON ;
NABoolean logDiagnostics =
CmpCommon::getDefault(EXE_DIAGNOSTIC_EVENTS) == DF_ON ;
NABoolean possibleMultipleCalls = generator->getRightSideOfFlow() ;
short scratchTresholdPct =
(short) CmpCommon::getDefaultLong(SCRATCH_FREESPACE_THRESHOLD_PERCENT);
// determione the memory usage (amount of memory as percentage from total
// physical memory used to initialize data structures)
unsigned short memUsagePercent =
(unsigned short) getDefault(BMO_MEMORY_USAGE_PERCENT);
short memPressurePct = (short)getDefault(GEN_MEM_PRESSURE_THRESHOLD);
historyRecLen = ROUND8(historyRecLen);
Lng32 maxNumberOfOLAPBuffers;
Lng32 maxRowsInOLAPBuffer;
Lng32 minNumberOfOLAPBuffers;
Lng32 numberOfWinOLAPBuffers;
Lng32 olapBufferSize;
computeHistoryParams(historyRecLen,
maxRowsInOLAPBuffer,
minNumberOfOLAPBuffers,
numberOfWinOLAPBuffers,
maxNumberOfOLAPBuffers,
olapBufferSize);
ComTdbSequence *sequenceTdb
= new(space) ComTdbSequence(readSeqExpr,
returnExpr,
postPred,
cancelExpression,
getMinFollowingRows(),
#pragma nowarn(1506) // warning elimination
historyRecLen,
historyAtpIndex,
childTdb,
givenCriDesc,
returnCriDesc,
(queue_index)getDefault(GEN_SEQFUNC_SIZE_DOWN),
(queue_index)getDefault(GEN_SEQFUNC_SIZE_UP),
getDefault(GEN_SEQFUNC_NUM_BUFFERS),
getDefault(GEN_SEQFUNC_BUFFER_SIZE),
olapBufferSize,
maxNumberOfOLAPBuffers,
numHistoryRows(),
getUnboundedFollowing(),
logDiagnostics,
possibleMultipleCalls,
scratchTresholdPct,
memUsagePercent,
memPressurePct,
maxRowsInOLAPBuffer,
minNumberOfOLAPBuffers,
numberOfWinOLAPBuffers,
noOverflow,
checkPartChangeExpr);
#pragma warn(1506) // warning elimination
generator->initTdbFields(sequenceTdb);
// update the estimated value of HistoryRowLength with actual value
//setEstHistoryRowLength(historyIds.getRowLength());
double sequenceMemEst = getEstimatedRunTimeMemoryUsage(sequenceTdb);
generator->addToTotalEstimatedMemory(sequenceMemEst);
if(!generator->explainDisabled()) {
Lng32 seqMemEstInKBPerCPU = (Lng32)(sequenceMemEst / 1024) ;
seqMemEstInKBPerCPU = seqMemEstInKBPerCPU/
(MAXOF(generator->compilerStatsInfo().dop(),1));
generator->setOperEstimatedMemory(seqMemEstInKBPerCPU);
generator->
setExplainTuple(addExplainInfo(sequenceTdb,
childExplainTuple,
0,
generator));
generator->setOperEstimatedMemory(0);
}
sequenceTdb->setScratchIOVectorSize((Int16)getDefault(SCRATCH_IO_VECTOR_SIZE_HASH));
sequenceTdb->setOverflowMode(generator->getOverflowMode());
sequenceTdb->setBmoMinMemBeforePressureCheck((Int16)getDefault(EXE_BMO_MIN_SIZE_BEFORE_PRESSURE_CHECK_IN_MB));
if(generator->getOverflowMode() == ComTdb::OFM_SSD )
sequenceTdb->setBMOMaxMemThresholdMB((UInt16)(ActiveSchemaDB()->
getDefaults()).
getAsLong(SSD_BMO_MAX_MEM_THRESHOLD_IN_MB));
else
sequenceTdb->setBMOMaxMemThresholdMB((UInt16)(ActiveSchemaDB()->
getDefaults()).
getAsLong(EXE_MEMORY_AVAILABLE_IN_MB));
// The CQD EXE_MEM_LIMIT_PER_BMO_IN_MB has precedence over the mem quota sys
NADefaults &defs = ActiveSchemaDB()->getDefaults();
UInt16 mmu = (UInt16)(defs.getAsDouble(EXE_MEM_LIMIT_PER_BMO_IN_MB));
UInt16 numBMOsInFrag = (UInt16)generator->getFragmentDir()->getNumBMOs();
if (mmu != 0)
sequenceTdb->setMemoryQuotaMB(mmu);
else {
// Apply quota system if either one the following two is true:
// 1. the memory limit feature is turned off and more than one BMOs
// 2. the memory limit feature is turned on
NABoolean mlimitPerCPU = defs.getAsDouble(EXE_MEMORY_LIMIT_PER_CPU) > 0;
if ( mlimitPerCPU || numBMOsInFrag > 1 ) {
double memQuota =
computeMemoryQuota(generator->getEspLevel() == 0,
mlimitPerCPU,
generator->getBMOsMemoryLimitPerCPU().value(),
generator->getTotalNumBMOsPerCPU(),
generator->getTotalBMOsMemoryPerCPU().value(),
numBMOsInFrag,
generator->getFragmentDir()->getBMOsMemoryUsage()
);
sequenceTdb->setMemoryQuotaMB( UInt16(memQuota) );
}
}
generator->setCriDesc(givenCriDesc, Generator::DOWN);
generator->setCriDesc(returnCriDesc, Generator::UP);
generator->setGenObj(this, sequenceTdb);
return 0;
}
// getHistoryAttributes
//
// Helper function that traverses the set of root sequence functions
// supplied by the compiler and constructs the set of all of the
// attributes that must be materialized in the history row.
//
void PhysSequence::getHistoryAttributes(const ValueIdSet &sequenceFunctions,
const ValueIdSet &outputFromChild,
ValueIdSet &historyAttributes,
NABoolean addConvNodes,
CollHeap *wHeap,
ValueIdMap *origAttributes) const
{
if(addConvNodes && !origAttributes) {
origAttributes = new (wHeap) ValueIdMap();
}
ValueIdSet children;
for(ValueId valId = sequenceFunctions.init();
sequenceFunctions.next(valId);
sequenceFunctions.advance(valId)) {
if(valId.getItemExpr()->isASequenceFunction()) {
ItemExpr *itmExpr = valId.getItemExpr();
switch(itmExpr->getOperatorType())
{
// The child needs to be in the history row.
//
case ITM_OFFSET:
case ITM_ROWS_SINCE:
case ITM_THIS:
case ITM_NOT_THIS:
// If the child needs to be in the history buffer, then
// add a Convert node to force the value to be moved to the
// history buffer.
if (addConvNodes)
{
itmExpr->child(0) =
addConvNode(itmExpr->child(0), origAttributes, wHeap);
}
historyAttributes += itmExpr->child(0)->getValueId();
break;
// The sequence function needs to be in the history row.
//
case ITM_RUNNING_SUM:
case ITM_RUNNING_COUNT:
case ITM_RUNNING_MIN:
case ITM_RUNNING_MAX:
case ITM_LAST_NOT_NULL:
historyAttributes += itmExpr->getValueId();
break;
/*
// after PhysSequence precode gen OLAP sum and count are already transform,ed into running
// this is used during optimization phase--
case ITM_OLAP_SUM:
case ITM_OLAP_COUNT:
case ITM_OLAP_RANK:
case ITM_OLAP_DRANK:
if (addConvNodes)
{
itmExpr->child(0) =
addConvNode(itmExpr->child(0), origAttributes, wHeap);
}
historyAttributes += itmExpr->child(0)->getValueId();
//historyAttributes += itmExpr->getValueId();
break;
*/
// The child and sequence function need to be in the history row.
//
case ITM_OLAP_MIN:
case ITM_OLAP_MAX:
case ITM_MOVING_MIN:
case ITM_MOVING_MAX:
// If the child needs to be in the history buffer, then
// add a Convert node to force the value to be moved to the
// history buffer.
if (addConvNodes)
{
itmExpr->child(0) =
addConvNode(itmExpr->child(0), origAttributes, wHeap);
}
historyAttributes += itmExpr->child(0)->getValueId();
historyAttributes += itmExpr->getValueId();
break;
case ITM_RUNNING_CHANGE:
if (itmExpr->child(0)->getOperatorType() == ITM_ITEM_LIST)
{
// child is a multi-valued expression
//
ExprValueId treePtr = itmExpr->child(0);
ItemExprTreeAsList changeValues(&treePtr,
ITM_ITEM_LIST,
RIGHT_LINEAR_TREE);
CollIndex nc = changeValues.entries();
ItemExpr *newChild = NULL;
if(addConvNodes) {
newChild = addConvNode(changeValues[nc-1], origAttributes, wHeap);
historyAttributes += newChild->getValueId();
} else {
historyAttributes += changeValues[nc-1]->getValueId();
}
// add each item in the list
//
for (CollIndex i = nc; i > 0; i--)
{
if(addConvNodes) {
ItemExpr *conv
= addConvNode(changeValues[i-1], origAttributes, wHeap);
newChild = new(wHeap) ItemList(conv, newChild);
newChild->synthTypeAndValueId(TRUE);
historyAttributes += conv->getValueId();
} else {
historyAttributes += changeValues[i-1]->getValueId();
}
}
if(addConvNodes) {
itmExpr->child(0) = newChild;
}
}
else
{
// If the child needs to be in the history buffer, then
// add a Convert node to force the value to be moved to the
// history buffer.
if (addConvNodes)
{
itmExpr->child(0) =
addConvNode(itmExpr->child(0), origAttributes, wHeap);
}
historyAttributes += itmExpr->child(0)->getValueId();
}
historyAttributes += itmExpr->getValueId();
break;
default:
CMPASSERT(0);
}
}
// Gather all the children, and if not empty, recurse down to the
// next level of the tree.
//
for(Lng32 i = 0; i < valId.getItemExpr()->getArity(); i++)
{
if (!outputFromChild.contains(valId.getItemExpr()->child(i)->getValueId()))
//!valId.getItemExpr()->child(i)->nodeIsPreCodeGenned())
{
children += valId.getItemExpr()->child(i)->getValueId();
}
}
}
if (NOT children.isEmpty())
{
getHistoryAttributes( children,
outputFromChild,
historyAttributes,
addConvNodes,
wHeap,
origAttributes);
}
} // PhysSequence::getHistoryAttributes
// computeHistoryBuffer
//
// Helper function that traverses the set of root sequence functions
// supplied by the compiler and dynamically determines the size
// of the history buffer.
//
void PhysSequence::computeHistoryRows(const ValueIdSet &sequenceFunctions,//historyIds
Lng32 &computedHistoryRows,
Lng32 &unableToCalculate,
NABoolean &unboundedFollowing,
Lng32 &minFollowingRows,
const ValueIdSet &outputFromChild)
{
ValueIdSet children;
ValueIdSet historyAttributes;
Lng32 value = 0;
for(ValueId valId = sequenceFunctions.init();
sequenceFunctions.next(valId);
sequenceFunctions.advance(valId))
{
if(valId.getItemExpr()->isASequenceFunction())
{
ItemExpr *itmExpr = valId.getItemExpr();
switch(itmExpr->getOperatorType())
{
// THIS and NOT THIS are not dynamically computed
//
case ITM_THIS:
case ITM_NOT_THIS:
break;
// The RUNNING functions and LastNotNull all need to go back just one row.
//
case ITM_RUNNING_SUM:
case ITM_RUNNING_COUNT:
case ITM_RUNNING_MIN:
case ITM_RUNNING_MAX:
case ITM_RUNNING_CHANGE:
case ITM_LAST_NOT_NULL:
computedHistoryRows = MAXOF(computedHistoryRows, 2);
break;
///set to unable to compute for now-- will change later to compte values from frameStart_ and frameEnd_
case ITM_OLAP_SUM:
case ITM_OLAP_COUNT:
case ITM_OLAP_MIN:
case ITM_OLAP_MAX:
case ITM_OLAP_RANK:
case ITM_OLAP_DRANK:
{
if ( !outputFromChild.contains(itmExpr->getValueId()))
{
ItmSeqOlapFunction * olap = (ItmSeqOlapFunction*)itmExpr;
if (olap->isFrameStartUnboundedPreceding()) //(olap->getframeStart() == - INT_MAX)
{
computedHistoryRows = MAXOF(computedHistoryRows, 2);
}
else
{
computedHistoryRows = MAXOF(computedHistoryRows, ABS(olap->getframeStart()) + 2);
}
if (!olap->isFrameEndUnboundedFollowing()) //(olap->getframeEnd() != INT_MAX)
{
computedHistoryRows = MAXOF(computedHistoryRows, ABS(olap->getframeEnd()) + 1);
}
if (olap->isFrameEndUnboundedFollowing()) //(olap->getframeEnd() == INT_MAX)
{
unboundedFollowing = TRUE;
if (olap->getframeStart() > 0)
{
minFollowingRows = ((minFollowingRows > olap->getframeStart()) ?
minFollowingRows : olap->getframeStart());
}
} else if (olap->getframeEnd() > 0)
{
minFollowingRows = ((minFollowingRows > olap->getframeEnd()) ?
minFollowingRows : olap->getframeEnd());
}
}
}
break;
// If 'rows since', we cannot determine how much history is needed.
case ITM_ROWS_SINCE:
unableToCalculate = 1;
break;
// The MOVING and OFFSET functions need to go back as far as the value
// of their second child.
//
// The second argument can be:
// Constant: for these, we can use the constant value to set the upper bound
// for the history buffer.
// ItmScalarMinMax(child0, child1) (with operType = ITM_SCALAR_MIN)
// - if child0 or child1 is a constant, then we can use either one
// to set the upper bound.
case ITM_MOVING_MIN:
case ITM_MOVING_MAX:
case ITM_OFFSET:
for(Lng32 i = 1; i < itmExpr->getArity(); i++)
{
if (itmExpr->child(i)->getOperatorType() != ITM_NOTCOVERED)
{
ItemExpr * exprPtr = itmExpr->child(i);
NABoolean negate;
ConstValue *cv = exprPtr->castToConstValue(negate);
if (cv AND cv->canGetExactNumericValue())
{
Lng32 scale;
Int64 value64 = cv->getExactNumericValue(scale);
if(scale == 0 && value64 >= 0 && value64 < INT_MAX)
{
value64 = (negate ? -value64 : value64);
value = MAXOF((Lng32)value64, value);
}
}
else
{
if (exprPtr->getOperatorType() == ITM_SCALAR_MIN)
{
for(Lng32 j = 0; j < exprPtr->getArity(); j++)
{
if (exprPtr->child(j)->getOperatorType()
!= ITM_NOTCOVERED)
{
ItemExpr * exprPtr1 = exprPtr->child(j);
NABoolean negate1;
ConstValue *cv1 = exprPtr1->castToConstValue(negate1);
if (cv1 AND cv1->canGetExactNumericValue())
{
Lng32 scale1;
Int64 value64_1 = cv1->getExactNumericValue(scale1);
if(scale1 == 0 && value64_1 >= 0 && value64_1 < INT_MAX)
{
value64_1 = (negate1 ? -value64_1 : value64_1);
value = MAXOF((Lng32)value64_1, value);
}
}
}
}
}
} // end of inner else
}// end of if
}// end of for
// Check if the value is greater than zero.
// If it is, then save the value, but first
// increment the returned ConstValue by one.
// Otherwise, the offset or moving value was unable
// to be calculated.
if (value > 0)
{
value++;
computedHistoryRows = MAXOF(computedHistoryRows, value);
value = 0;
}
else
unableToCalculate = 1;
break;
default:
CMPASSERT(0);
}
}
// Gather all the children, and if not empty, recurse down to the
// next level of the tree.
//
for(Lng32 i = 0; i < valId.getItemExpr()->getArity(); i++) {
if (//valId.getItemExpr()->child(i)->getOperatorType() != ITM_NOTCOVERED //old stuff
!outputFromChild.contains(valId.getItemExpr()->child(i)->getValueId()))
{
children += valId.getItemExpr()->child(i)->getValueId();
}
}
}
if (NOT children.isEmpty())
{
computeHistoryRows(children,
computedHistoryRows,
unableToCalculate,
unboundedFollowing,
minFollowingRows,
outputFromChild);
}
} // PhysSequence::computeHistoryRows
/********************************************************************
* Input: Selection predicates for the scan node, boolean indicating if
* it is a indexOnlyIndex, reference parameter that will indicate if
* IndexJoin is viable or not, GroupAttributes for the group and characteristic
* inputs
* Output: MdamFlag indicating if the index key access is good enough for
* MDAM access (if a index does not have good MDAM access we have to
* scan the whole index because single subset also will not have any
* keys to apply)
* IndexJoin flag indicating if index join cost would exceed base table
* access or not.
********************************************************************/
MdamFlags IndexDesc::pruneMdam(const ValueIdSet& preds,
NABoolean indexOnlyIndex,
IndexJoinSelectivityEnum&
selectivityEnum /* out*/ ,
const GroupAttributes * groupAttr,
const ValueIdSet * inputValues) const
{
CollIndex numEmptyColumns=0;
CostScalar numSkips = csOne;
ValueIdSet emptyColumns;
ValueId vid;
if(indexOnlyIndex)
selectivityEnum = INDEX_ONLY_INDEX;
else
selectivityEnum = INDEX_JOIN_VIABLE;
if(preds.isEmpty()) return MDAM_OFF;
//calculate how many key columns don't have any predicates
for(CollIndex i=0;i<indexKey_.entries();i++)
{
if(preds.referencesTheGivenValue(indexKey_[i],vid))
break;
else
numEmptyColumns++;
}
//if we don't have any empty columns or we don't have to evaluate if index
//join is promising or not then just return
if(numEmptyColumns>=1 OR NOT indexOnlyIndex)
{
IndexDescHistograms ixHistogram(*this,
(indexOnlyIndex?numEmptyColumns:indexKey_.entries()));
NABoolean multiColUecAvail = ixHistogram.isMultiColUecInfoAvail();
ColumnOrderList keyPredsByCol(indexKey_);
for(CollIndex j=0;j<numEmptyColumns;j++)
{
emptyColumns.insert(indexKey_[j]);
if(j==0 OR multiColUecAvail == FALSE)
{
//no MCUec so just multiply the empty columns UEC count to
//calculate MDAM skips
numSkips *=(ixHistogram.getColStatsForColumn(indexKey_[j])).
getTotalUec().getCeiling();
}
else // otherwise try to use MCUec
{
NABoolean uecFound = FALSE;
CostScalar correctUec = csOne;
CostScalar combinedUECCount = csOne;
// first let's see if there is multiColUec count for the skipped columns
// so far. If there is that will be number of skips. If there isn't then
// get the best estimate of UEC count for the current column using MCUec
// if possible otherwise just using single column histograms.
combinedUECCount = ixHistogram.getUecCountForColumns(emptyColumns);
if(combinedUECCount >0)
{
numSkips = combinedUECCount;
}
else
{
uecFound = ixHistogram.estimateUecUsingMultiColUec(keyPredsByCol,j,correctUec);
if(uecFound==TRUE)
{
numSkips *= correctUec;
}
else
{
numSkips *=(ixHistogram.getColStatsForColumn(indexKey_[j])).
getTotalUec().getCeiling();
}
}
}
}
CostScalar rowCount = ixHistogram.getRowCount();
CostScalar numIndexBlocks = rowCount /getEstimatedRecordsPerBlock();
CostScalar numProbes = csOne;
CostScalar numBaseTableBlocks = csOne;
CostScalar inputProbes = csOne;
// Pass any selectivity hint provided by the user
const SelectivityHint * selHint = tableDesc_->getSelectivityHint();
const CardinalityHint * cardHint = tableDesc_->getCardinalityHint();
// If it is an index join then compute the number probes into the base
// table. If the alternate index is not selective enough, we will have
// lots of them making the index quite expensive.
if(NOT indexOnlyIndex)
{
if((groupAttr->getInputLogPropList()).entries() >0)
{
//if there are incoming probes to the index. i.e. if the index join
//is under another nested join or TSJ then compute result for all
//probes. We are using the initial inputEstLogProp to compute the
//resulting cardinality. It is possible that for the same group and
//different inputEstLogProp would provide less row count per probe.
//So in FileScanRule::nextSubstitute() we make sure that the context
//inputEstLogProp is in the error range of this inputEstLogProp.
// Ex. select * from lineitem, customer, nation
// where l_custkey < c_custkey and c_custkey = n_nationkey;
//Now if we were evaluating lineitem indexes where the outer was customer
//we would want to exclude alternate index on custkey whereas if nation got
//pushed below customer then range of values would be fewer and max value
//being less would make alternate index on custkey quite attractive.
ixHistogram.
applyPredicatesWhenMultipleProbes(preds,
*((groupAttr->getInputLogPropList())[0]),
*inputValues,
TRUE,
selHint,
cardHint,
NULL,
REL_SCAN);
inputProbes = MIN_ONE((groupAttr->getInputLogPropList())[0]->getResultCardinality());
}
else
{
RelExpr * dummyExpr = new (STMTHEAP) RelExpr(ITM_FIRST_ITEM_OP,
NULL,
NULL,
STMTHEAP);
ixHistogram.applyPredicates(preds, *dummyExpr, selHint, cardHint, REL_SCAN);
}
numProbes = ixHistogram.getRowCount();
numBaseTableBlocks = rowCount / tableDesc_->getClusteringIndex()->
getEstimatedRecordsPerBlock();
double readAhead = CURRSTMT_OPTDEFAULTS->readAheadMaxBlocks();
// although we compute cardinality from the index for all probes we
// do the comparison for per probe. The assumption is that per probe
// the upper bound of cost is scanning the whole base table.
if(numProbes/inputProbes + MINOF((numIndexBlocks / readAhead),numSkips)
> (numBaseTableBlocks/readAhead))
{
selectivityEnum = EXCEEDS_BT_SCAN;
}
}
//Does the number of skips exceed the cost of scanning the index.
if((indexOnlyIndex AND numSkips <=
(numIndexBlocks * CURRSTMT_OPTDEFAULTS->mdamSelectionDefault())) OR
(NOT indexOnlyIndex AND numSkips + numProbes/inputProbes <=
(numBaseTableBlocks * CURRSTMT_OPTDEFAULTS->mdamSelectionDefault())))
return MDAM_ON;
}
else
return MDAM_ON;
return MDAM_OFF;
}