void
generateMarkedEntries(Generator *generator, ValueIdSet &marks)
{
for(ValueId vid = marks.init(); marks.next(vid); marks.advance(vid)) {
MapInfo *mapInfo =
generator->getMapInfoAsIs(vid);
if(mapInfo)
mapInfo->codeGenerated();
}
}
// 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
NABoolean TableDesc::hasIdentityColumnInClusteringKey() const
{
ValueIdSet pKeyColumns = clusteringIndex_->getIndexKey();
NAColumn * column = NULL;
for(ValueId id = pKeyColumns.init(); pKeyColumns.next(id);
pKeyColumns.advance(id))
{
column = id.getNAColumn();
if (column && column->isIdentityColumn())
return TRUE;
}
return FALSE;
}
void NormWA::locateVEGRegionAndMarkToBeMergedRecursively(const ValueId & vid)
{
VEGRegion* toBeMergedRegion = locateVEGRegionAndMarkToBeMerged(vid);
if (toBeMergedRegion)
{
ValueIdSet nullInstValues;
toBeMergedRegion->gatherInstantiateNullMembers(nullInstValues);
for (ValueId exprId = nullInstValues.init();
nullInstValues.next(exprId);
nullInstValues.advance(exprId))
{
locateVEGRegionAndMarkToBeMergedRecursively(exprId);
}
}
}
void MvQueryRewriteHandler::dumpAnalysisToFile(QueryAnalysis* qa, RelExpr* expr)
{
// Dump the QueryAnalysis data to a file.
NAString analysisFileName = fileNamePrefix_ + ".analysis";
NAString str;
expr->unparse(str, OPTIMIZER_PHASE, MVINFO_FORMAT);
str += "\n";
str += qa->getText();
// Add in some stuff to look at join predicates for the JBBCs.
str += "Join Predicates\n";
str += "===============";
char buffer[20];
ARRAY(JBB*) jbbs = qa->getJBBs();
for (CollIndex jbbInx = 0; jbbInx < jbbs.entries(); jbbInx++)
{
JBB* jbb = jbbs[jbbInx];
str_itoa(jbbInx, buffer);
((str += "\nJBB #") += NAString(buffer)) += ":\n";
CANodeIdSet jbbcs = jbb->getJBBCs();
for (CANodeId jbbcId=jbbcs.init(); jbbcs.next(jbbcId); jbbcs.advance(jbbcId) )
{
str_itoa(jbbcId, buffer);
((str += "\nJBBC with CANodeId ") += NAString(buffer)) += ":\n";
ValueIdSet joinPreds = jbbcId.getNodeAnalysis()->getJBBC()->getJoinPreds();
str += valueIdSetGetText(joinPreds);
if (joinPreds.entries() > 0)
{
str.append("\n(value ids of predicates are ");
NABoolean first = true;
for (ValueId jpVid=joinPreds.init(); joinPreds.next(jpVid); joinPreds.advance(jpVid))
{
if (first)
first = FALSE;
else
str.append(", ");
str_itoa(jpVid, buffer);
str.append(buffer);
}
str.append(")\n");
}
}
str += '\n';
}
dumpToFile(analysisFileName.data(), str.data());
} // dumpAnalysisToFile()
void PhysSequence::seperateReadAndReturnItems(
//ValueIdSet & readPhaseSet,
//ValueIdSet & returnPhaseSet,
CollHeap *wHeap)
{
ValueIdSet outputFromChild = child(0)->getGroupAttr()->getCharacteristicOutputs();
ValueIdSet seqFuncs = sequenceFunctions();
for(ValueId valId = seqFuncs.init();
seqFuncs.next(valId);
seqFuncs.advance(valId))
{
computeReadNReturnItems(valId,
valId,
//sequenceFunctions(),
//returnSeqFunctions(),
outputFromChild,
wHeap);
}
}
// TableDesc::isKeyIndex()
// Parameter is an secondary index on the table. Table checks to see
// if the keys of the secondary index is built using the primary key
// of the table. If it is return true otherwise false.
NABoolean TableDesc::isKeyIndex(const IndexDesc * idesc) const
{
ValueIdSet pKeyColumns = clusteringIndex_->getIndexKey();
ValueIdSet indexColumns = idesc->getIndexKey();
ValueIdSet basePKeys=pKeyColumns.convertToBaseIds();
for(ValueId id = indexColumns.init(); indexColumns.next(id);
indexColumns.advance(id))
{
ValueId baseId = ((BaseColumn *)(((IndexColumn *)id.getItemExpr())->
getDefinition().getItemExpr()))->getValueId();
if(NOT basePKeys.contains(baseId))
{
return FALSE;
}
}
return TRUE;
}
void HbaseSearchSpec::addColumnNames(const ValueIdSet& vs)
{
// TEMP TEMP. Not all needed column names are being set up.
// for now, return without populating result.
// that will cause all columns to be retrieved.
//return;
for (ValueId vid = vs.init(); vs.next(vid); vs.advance(vid)) {
ItemExpr* ie = vid.getItemExpr();
NAString colName;
if ( ie->getOperatorType() == ITM_BASECOLUMN ) {
colName = ((BaseColumn*)ie)->getColName();
} else
if ( ie->getOperatorType() == ITM_INDEXCOLUMN ) {
colName = ((IndexColumn*)ie)->getNAColumn()->getIndexColName();
}
if (NOT colNames_.contains(colName))
colNames_.insert(colName);
}
}
// 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;
}
// 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
// ------------------------------------------------------------------------------
// create my colStats based on my child's output, by converting the columns to
// that of mine
// ------------------------------------------------------------------------------
void EstLogProp::mapOutputsForUpdate(const GenericUpdate & updateExpr,
const ValueIdMap & updateSelectValueIdMap)
{
TableDesc * updateTable = updateExpr.getTableDesc();
for ( CollIndex i = 0; i < colStats().entries(); i++ )
{
ColStatDescSharedPtr colStatPtr = (colStats())[i];
const ValueId columnId = colStatPtr->getVEGColumn();
ValueId updateColVEGOutputId;
updateSelectValueIdMap.mapValueIdUp(updateColVEGOutputId, columnId);
ValueId updateBaseColumnId;
if (updateColVEGOutputId != columnId)
{
updateBaseColumnId = updateColVEGOutputId;
ValueIdSet baseColumns;
updateColVEGOutputId.getItemExpr()->findAll( ITM_BASECOLUMN, baseColumns, TRUE, TRUE );
// from all the columns extracted, get the one for Insert table
TableDesc * thisTable = NULL;
for (ValueId column = baseColumns.init(); baseColumns.next(column);
baseColumns.advance(column) )
{
ItemExpr * columnExpr = column.getItemExpr();
thisTable = ((BaseColumn *)columnExpr)->getTableDesc();
if (thisTable == updateTable)
{
// set my column as the base column
updateBaseColumnId = column;
break;
}
}
ColStatsSharedPtr inColStats = colStatPtr->getColStats();
ColStatsSharedPtr colStatsForUpdate(new (STMTHEAP) ColStats (*inColStats,STMTHEAP));
colStatsForUpdate->setStatColumn(updateBaseColumnId.getNAColumn());
// use this ColStat to generate new ColStat corresponding to the char output
// of the Update expression
ColStatDescSharedPtr colStatDescForUpdate(new (STMTHEAP) ColStatDesc(colStatsForUpdate,
updateBaseColumnId, // ValueId of the column that will be used
// as a column name, VEG and mergeStats
STMTHEAP), STMTHEAP);
colStatDescForUpdate->VEGColumn() = updateColVEGOutputId;
colStatDescForUpdate->mergeState().clear() ;
colStatDescForUpdate->mergeState().insert(updateBaseColumnId);
// Remove the old colStat and insert this colStat into the result colStatDescList
colStats().removeAt( i );
colStats().insertDeepCopyAt(i, colStatDescForUpdate, // colStats to be copied
1, // scale
FALSE);
}
}
}
// compress the histograms based on query predicates on this table
void TableDesc::compressHistogramsForCurrentQuery()
{
// if there are some column statistics
if ((colStats_.entries() != 0) &&
(table_) &&
(table_->getExtendedQualName().getSpecialType() == ExtendedQualName::NORMAL_TABLE))
{ // if 1
// check if query analysis info is available
if(QueryAnalysis::Instance()->isAnalysisON())
{ // if 2
// get a handle to the query analysis
QueryAnalysis* queryAnalysis = QueryAnalysis::Instance();
// get a handle to the table analysis
const TableAnalysis * tableAnalysis = getTableAnalysis();
if(!tableAnalysis)
return;
// iterate over statistics for each column
for(CollIndex i = 0; i < colStats_.entries(); i++)
{ // for 1
// Get a handle to the column's statistics descriptor
ColStatDescSharedPtr columnStatDesc = colStats_[i];
// get a handle to the ColStats
ColStatsSharedPtr colStats = columnStatDesc->getColStats();
// if this is a single column, as opposed to a multicolumn
if(colStats->getStatColumns().entries() == 1)
{ // if 3
// get column's value id
const ValueId columnId = columnStatDesc->getColumn();
// get column analysis
ColAnalysis* colAnalysis = queryAnalysis->getColAnalysis(columnId);
if(!colAnalysis) continue;
ValueIdSet predicatesOnColumn =
colAnalysis->getReferencingPreds();
// we can compress this column's histogram if there
// is a equality predicate against a constant
ItemExpr *constant = NULL;
NABoolean colHasEqualityAgainstConst =
colAnalysis->getConstValue(constant);
// if a equality predicate with a constant was found
// i.e. predicate of the form col = 5
if (colHasEqualityAgainstConst)
{ // if 4
if (constant)
// compress the histogram
columnStatDesc->compressColStatsForQueryPreds(constant,constant);
} // if 4
else { // else 4
// since there is no equality predicates we might still
// be able to compress the column's histogram based on
// range predicates against a constant. Following are
// examples of such predicates
// * col > 1 <-- predicate defines a lower bound
// * col < 3 <-- predicate defines a upper bound
// * col >1 and col < 30 <-- window predicate, define both bounds
ItemExpr * lowerBound = NULL;
ItemExpr * upperBound = NULL;
// Extract predicates from range spec and add it to the
// original predicate set otherwise isARangePredicate() will
// return FALSE, so histgram compression won't happen.
ValueIdSet rangeSpecPred(predicatesOnColumn);
for (ValueId predId= rangeSpecPred.init();
rangeSpecPred.next(predId);
rangeSpecPred.advance(predId))
{
ItemExpr * pred = predId.getItemExpr();
if ( pred->getOperatorType() == ITM_RANGE_SPEC_FUNC )
{
ValueIdSet vs;
((RangeSpecRef *)pred)->getValueIdSetForReconsItemExpr(vs);
// remove rangespec vid from the original set
predicatesOnColumn.remove(predId);
// add preds extracted from rangespec to the original set
predicatesOnColumn.insert(vs);
}
}
// in the following loop we iterate over all the predicates
// on this column. If there is a range predicate e.g. a > 2
// or a < 3, then we use that to define upper and lower bounds.
// Given predicate a > 2, we get a lower bound of 2.
// Given predicate a < 3, we get a upper bound of 3.
// The bound are then passed down to the histogram
// compression methods.
// iterate over predicates to see if any of them is a range
// predicate e.g. a > 2
for (ValueId predId= predicatesOnColumn.init();
predicatesOnColumn.next(predId);
predicatesOnColumn.advance(predId))
{ // for 2
// check if this predicate is a range predicate
ItemExpr * predicateOnColumn = predId.getItemExpr();
if (predicateOnColumn->isARangePredicate())
{ // if 5
// if a predicate is a range predicate we need to find out more
// information regarding the predicate to see if it can be used
// to compress the columns histogram. We look for the following:
// * The predicate is against a constant e.g. a > 3 and not against
// another column e.g. a > b
// Also give a predicate we need to find out what side is the column
// and what side is the constant. Normally people write a range predicate
// as a > 3, but the same could be written as 3 < a.
// Also either on of the operands of the range predicate might be
// a VEG, if so then we need to dig into the VEG to see where is
// the constant and where is the column.
// check the right and left children of this predicate to
// see if one of them is a constant
ItemExpr * leftChildItemExpr = (ItemExpr *) predicateOnColumn->getChild(0);
ItemExpr * rightChildItemExpr = (ItemExpr *) predicateOnColumn->getChild(1);
// by default assume the literal is at right i.e. predicate of
// the form a > 2
NABoolean columnAtRight = FALSE;
// check if right child of predicate is a VEG
if ( rightChildItemExpr->getOperatorType() == ITM_VEG_REFERENCE)
{ // if 6
// if child is a VEG
VEGReference * rightChildVEG = (VEGReference *) rightChildItemExpr;
// check if the VEG contains the current column
// if it does contain the current column then
// the predicate has the column on right and potentially
// a constant on the left.
if(rightChildVEG->getVEG()->getAllValues().contains(columnId))
{ // if 7
// column is at right i.e. predicate is of the form
// 2 < a
columnAtRight = TRUE;
} // if 7
} // if 6
else { // else 6
// child is not a VEG
if ( columnId == rightChildItemExpr->getValueId() )
{ // if 8
// literals are at left i.e. predicate is of the form
// (1,2) < (a, b)
columnAtRight = TRUE;
} // if 8
} // else 6
ItemExpr * potentialConstantExpr = NULL;
// check if the range predicate is against a constant
if (columnAtRight)
{ // if 9
// the left child is potentially a constant
potentialConstantExpr = leftChildItemExpr;
} // if 9
else { // else 9
// the right child is potentially a constant
potentialConstantExpr = rightChildItemExpr;
} // else 9
// initialize constant to NULL before
// looking for next constant
constant = NULL;
// check if potentialConstantExpr contains a constant.
// we need to see if this range predicate is a predicate
// against a constant e.g col > 1 and not a predicate
// against another column e.g. col > anothercol
// if the expression is a VEG
if ( potentialConstantExpr->getOperatorType() == ITM_VEG_REFERENCE)
{ // if 10
// expression is a VEG, dig into the VEG to
// get see if it contains a constant
VEGReference * potentialConstantExprVEG =
(VEGReference *) potentialConstantExpr;
potentialConstantExprVEG->getVEG()->\
getAllValues().referencesAConstValue(&constant);
} // if 10
else { // else 10
// express is not a VEG, it is a constant
if ( potentialConstantExpr->getOperatorType() == ITM_CONSTANT )
constant = potentialConstantExpr;
} // else 10
// if predicate involves a constant, does the constant imply
// a upper bound or lower bound
if (constant)
{ // if 11
// if range predicate has column at right e.g. 3 > a
if (columnAtRight)
{ // if 12
if ( predicateOnColumn->getOperatorType() == ITM_GREATER ||
predicateOnColumn->getOperatorType() == ITM_GREATER_EQ)
{ // if 13
if (!upperBound)
upperBound = constant;
} // if 13
else
{ // else 13
if (!lowerBound)
lowerBound = constant;
} // else 13
} // if 12
else { // else 12
// range predicate has column at left e.g. a < 3
if ( predicateOnColumn->getOperatorType() == ITM_LESS ||
predicateOnColumn->getOperatorType() == ITM_LESS_EQ)
{ // if 14
if (!upperBound)
upperBound = constant;
} // if 14
else
{ // else 14
if (!lowerBound)
lowerBound = constant;
} // else 14
} // else 12
} // if 11
} // if 5
} // for 2
// if we found a upper bound or a lower bound
if (lowerBound || upperBound)
{
// compress the histogram based on range predicates
columnStatDesc->compressColStatsForQueryPreds(lowerBound, upperBound);
}
} // else 4
} // if 3
} // for 1
} // if 2
} // if 1
// All histograms compressed. Set the histCompressed flag to TRUE
histsCompressed(TRUE);
}
Join* MultiJoin::splitSubset(const JBBSubset & leftSet,
const JBBSubset & rightSet,
NABoolean reUseMJ) const
{
// At this point assert that none of the subsets has a group by member
CMPASSERT ( (jbbSubset_.getGB() == NULL_CA_ID) &&
(leftSet.getGB() == NULL_CA_ID) &&
(rightSet.getGB() == NULL_CA_ID) );
#ifndef NDEBUG
// assert that left + right == subSet_
// and left intersect right = phi
CANodeIdSet unionSet(leftSet.getJBBCs());
CANodeIdSet intersectSet(leftSet.getJBBCs());
unionSet += rightSet.getJBBCs();
intersectSet.intersectSet(rightSet.getJBBCs());
CMPASSERT ( (unionSet == jbbSubset_.getJBBCs()) &&
(intersectSet.entries() == 0 ));
#endif
// Note: Joins including left, semi, anti semi are only created when
// a single jbbc connected via one of them is split as a single right
// child. InnerNonSemi joins can be created for any split i.e. any
// number of jbbcs on the left and the right of the join, but special
// joins (i.e. left, semi and anti semi joins) are only created when
// there is a single right child i.e. the rightSet contains only one
// jbbc that is connected via a special join. This is enforced as follows
//
// * The leftSet should be legal: This means that for every jbbc in the
// leftSet any predecessor jbbcs should be present in the leftSet.
// * The rightSet is either a single jbbc or if the rightSet has more
// than one jbbc then it should be legal, note that a jbbc connected
// via a special join is not a legal set by itself but we allow
// creation of special joins assuming the predecessors are present
// in the leftSet.
//
// An implicit assumption here is that 'this' MultiJoin is legal, which
// is fair since apart from the top level multijoin, rest of the multijoins
// are produced by splitting the top level multijoin. This method should
// not produce illegal multijoins, since we check both leftSet and rightSet
// for legality. Only time we don't check for legality is when the rightChild
// is a single jbbc, and a single jbbc does not result in a multijoin.
if(!leftSet.legal())
return NULL;
if((rightSet.getJBBCs().entries() > 1) && (!rightSet.legal()))
return NULL;
// everything here goes to statement heap
CollHeap* outHeap = CmpCommon::statementHeap();
RelExpr* child0 = generateSubsetExpr(leftSet, reUseMJ);
RelExpr* child1 = generateSubsetExpr(rightSet, reUseMJ);
// Flag to remember to pass on the derivedFromRoutineJoin flag if needed.
NABoolean derivedFromRoutineJoin(FALSE);
// now form a JoinExpr with these left and right children.
Join * result = NULL;
// if the rightSet is a single jbbc, then it could be connected via
// a special join. In such a case we have to create the appropriate
// join operator
if(rightSet.getJBBCs().entries() == 1){
JBBC * rightChild = rightSet.getJBBCs().getFirst().getNodeAnalysis()
->getJBBC();
Join * rightChildParentJoin = rightChild->getOriginalParentJoin();
// If rightChildParentJoin is NULL, then the child is the left
// child of the left most join and is considered to be connected
// via a InnerNonSemi join.
if(rightChildParentJoin)
{
if(rightChildParentJoin->derivedFromRoutineJoin())
derivedFromRoutineJoin = TRUE;
if(rightChildParentJoin->isSemiJoin())
result = new (outHeap) Join(child0, child1, REL_SEMIJOIN, NULL);
if(rightChildParentJoin->isAntiSemiJoin())
result = new (outHeap) Join(child0, child1, REL_ANTI_SEMIJOIN, NULL);
if(rightChildParentJoin->isLeftJoin())
{
// left joins can have filter preds, i.e. predicates that
// are applied as filters after applying the join predicate.
// We need to set them here.
result = new (outHeap) Join(child0, child1, REL_LEFT_JOIN, NULL);
result->setSelectionPredicates(rightChild->getLeftJoinFilterPreds());
}
if(rightChildParentJoin->isRoutineJoin())
{
derivedFromRoutineJoin = TRUE;
result = new (outHeap) Join(child0, child1, REL_ROUTINE_JOIN, NULL);
ValueIdSet routineJoinFilterPreds = rightChild->getRoutineJoinFilterPreds();
ValueIdSet predsToAddToRoutineJoin;
// add covered filter preds
for (ValueId filterPred= routineJoinFilterPreds.init();
routineJoinFilterPreds.next(filterPred);
routineJoinFilterPreds.advance(filterPred) )
{
if(jbbSubset_.coversExpr(filterPred))
predsToAddToRoutineJoin += filterPred;
}
result->setSelectionPredicates(predsToAddToRoutineJoin);
}
if(result)
{
// set the join predicate for special joins, note predicates
// for regular InnerNonSemi joins are set as selection predicates
// in the join relexpr.
result->setJoinPred(rightChild->getPredsWithPredecessors());
result->nullInstantiatedOutput().insert(rightChild->
nullInstantiatedOutput());
}
}
}
// The join to be created is a regular InnerNonSemi join
if (!result)
result = new (outHeap) Join(child0, child1, REL_JOIN, NULL);
// Make sure we carry the derivedFromRoutineJoin flag with us
if (derivedFromRoutineJoin)
result->setDerivedFromRoutineJoin();
// Share my groupAttr with result
result->setGroupAttr(getGroupAttr());
// get inner join predicates
ValueIdSet selPreds = rightSet.joinPredsWithOther(leftSet);
// get left join filter preds if any
selPreds += result->getSelectionPredicates();
result->setSelectionPredicates(selPreds);
result->findEquiJoinPredicates();
// May be I could save a little if i pushdown only to the child(ren)
// that are not already JBBCs, i.e. multijoins
result->pushdownCoveredExpr
(result->getGroupAttr()->getCharacteristicOutputs(),
result->getGroupAttr()->getCharacteristicInputs(),
result->selectionPred());
// We used CutOp as children, to avoid pushing predicates to JBBCs.
// Now put the actual expression back in case the child is a JBBCs
if(leftSet.getJBBCs().entries() == 1)
result->setChild(0, getJBBCRelExpr(leftSet.getJBBCs().getFirst()));
// We used CutOp as children, to avoid pushing predicates to JBBCs.
// Now put the actual expression back in case the child is a JBBCs
if(rightSet.getJBBCs().entries() == 1)
result->setChild(1, getJBBCRelExpr(rightSet.getJBBCs().getFirst()));
// Temp fixup. We need to take the selectionPred out of MultiJoin
// for now to prevent that pushed expr from being there. selectionPred
// is not being used now in MultiJoin xxx.
if (leftSet.getJBBCs().entries() > 1)
result->child(0)->selectionPred().clear();
if (rightSet.getJBBCs().entries() > 1)
result->child(1)->selectionPred().clear();
return result;
}
