template <class T> void FastStatsHist<T>::addRowset(Lng32 numRows)
{
T* dataPtr = (T*)group_->nextData;
Int32 dataLen = group_->ISlength;
short* nullIndic = group_->nullIndics;
if (totalFreq_ == 0)
min_ = max_ = *dataPtr;
totalFreq_ += numRows; //@ZXbl -- should exclude nulls from this count?
// Use strNextData instead of nextData for char types.
switch (group_->ISdatatype)
{
case REC_BYTE_F_ASCII:
// This fails for non-char* instantiations of the template.
// Also, it ISdatatype for char is ISFixedChar or similar.
// When these types are added, watch out for ptr arith
// when advancing dataPtr below.
//dataPtr = (char*)group_->strNextData;
//break;
case REC_BYTE_F_DOUBLE:
case REC_BYTE_V_ASCII:
case REC_BYTE_V_DOUBLE:
HS_ASSERT(FALSE);
break;
default:
break;
}
for (Int64 i=0; i<numRows; i++)
{
if (nullIndic && *nullIndic++ == -1)
nullCount_++;
else
{
// Update min or max if the encoded value is not within their range.
// @ZXbl -- need to encode if char, using EncVal_encodeString (in optimizer/EncodedValue.cpp).
HS_ASSERT(!DFS2REC::isAnyCharacter(group_->ISdatatype));
if (min_ > *dataPtr)
min_ = *dataPtr;
else if (max_ < *dataPtr)
max_ = *dataPtr;
cbf_->insert((char*)dataPtr, dataLen);
}
dataPtr++;
}
}
void HSTableDef::setNATable()
{
//BindWA bindWA(ActiveSchemaDB(), CmpCommon::context(), FALSE, getIsNativeHbaseOrHive());
BindWA bindWA(ActiveSchemaDB(), CmpCommon::context(), FALSE,
HSGlobalsClass::isNativeCat(*catalog_));
CorrName corrName(*object_, STMTHEAP, *schema_, *catalog_);
if (isVolatile())
corrName.setIsVolatile(TRUE);
Scan scan(corrName, NULL, REL_SCAN, STMTHEAP);
ULng32 flagToSet = 0; // don't turn on flag unless next 'if' is true
if (CmpCommon::context()->sqlSession()->volatileSchemaInUse())
flagToSet = ALLOW_VOLATILE_SCHEMA_IN_TABLE_NAME;
// set ALLOW_VOLATILE_SCHEMA_IN_TABLE_NAME bit in Sql_ParserFlags
// if needed, and return it to its entry value on exit
PushAndSetSqlParserFlags savedParserFlags(flagToSet);
scan.bindNode(&bindWA);
if (!bindWA.errStatus())
{
naTbl_ = bindWA.getNATable(corrName);
HS_ASSERT(naTbl_);
objectType_ = naTbl_->getObjectType();
}
}
Lng32 FormatRow(const HSColumnStruct *srcDesc,
const char *src,
HSDataBuffer &target)
{
const Lng32 REC_INTERVAL = REC_MIN_INTERVAL;
Lng32 retcode = 0;
const Lng32 workBufLen = 4096;
NAWchar workBuf[workBufLen];
Lng32 type = srcDesc->datatype;
NAWString wStr;
//The input source buffer will always be in the following form and will
//contain unicode format. We need to separate the buffer accordingly.
// |-------|--------------|
// SRC -->| LEN | DATA |
// |-------|--------------|
short inDataLen;
memcpy((char*)&inDataLen, src, sizeof(short));
const NAWchar *inData = (NAWchar*)(src + sizeof(short));
if (DFS2REC::isInterval(type))
type = REC_INTERVAL;
if (DFS2REC::isAnyCharacter(type))
{
wStr = WIDE_("'");
for (short i = 0; i < inDataLen/sizeof(NAWchar); i++)
{
if (inData[i] == NAWchar('\0'))
wStr += NAWchar('\1'); /* convert x00 to x01 */
else
{
wStr += inData[i];
if (inData[i] == NAWchar('\''))
wStr.append(WIDE_("'"));
}
}
wStr.append(WIDE_("'"));
target = wStr.data();
}
else
{
switch (type)
{
case REC_DATETIME:
{
switch (srcDesc->precision)
{
case REC_DTCODE_DATE:
{
wStr = WIDE_("DATE '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("'"));
break;
}
case REC_DTCODE_TIME:
{
wStr = WIDE_("TIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("'"));
break;
}
case REC_DTCODE_TIMESTAMP:
{
wStr = WIDE_("TIMESTAMP '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("'"));
break;
}
// Here begin a number of cases that are only possible with MP datetime types.
// LCOV_EXCL_START :mp
case REC_DTCODE_YEAR:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' YEAR"));
break;
}
case REC_DTCODE_YEAR_MONTH:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' YEAR TO MONTH"));
break;
}
case REC_DTCODE_YEAR_HOUR:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' YEAR TO HOUR"));
break;
}
case REC_DTCODE_YEAR_MINUTE:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' YEAR TO MINUTE"));
break;
}
case REC_DTCODE_MONTH:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' MONTH"));
break;
}
case REC_DTCODE_MONTH_DAY:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' MONTH TO DAY"));
break;
}
case REC_DTCODE_MONTH_HOUR:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' MONTH TO HOUR"));
break;
}
case REC_DTCODE_MONTH_MINUTE:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' MONTH TO MINUTE"));
break;
}
case REC_DTCODE_MONTH_SECOND:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
if (srcDesc->scale == 0)
wStr.append(WIDE_("' MONTH TO SECOND"));
else
{
wStr.append(WIDE_("' MONTH TO "));
wStr.append(appendFraction(srcDesc->scale));
}
break;
}
case REC_DTCODE_DAY:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' DAY"));
break;
}
case REC_DTCODE_DAY_HOUR:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' DAY TO HOUR"));
break;
}
case REC_DTCODE_DAY_MINUTE:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' DAY TO MINUTE"));
break;
}
case REC_DTCODE_DAY_SECOND:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
if (srcDesc->scale == 0)
wStr.append(WIDE_("' DAY TO SECOND"));
else
{
wStr.append(WIDE_("' DAY TO "));
wStr.append(appendFraction(srcDesc->scale));
}
break;
}
case REC_DTCODE_HOUR:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' HOUR"));
break;
}
case REC_DTCODE_HOUR_MINUTE:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' HOUR TO MINUTE"));
break;
}
case REC_DTCODE_MINUTE:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
wStr.append(WIDE_("' MINUTE"));
break;
}
case REC_DTCODE_MINUTE_SECOND:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
if (srcDesc->scale == 0)
wStr.append(WIDE_("' MINUTE TO SECOND"));
else
{
wStr.append(WIDE_("' MINUTE TO "));
wStr.append(appendFraction(srcDesc->scale));
}
break;
}
case REC_DTCODE_SECOND:
{
wStr = WIDE_("DATETIME '");
wStr.append(inData, inDataLen/sizeof(NAWchar));
if (srcDesc->scale == 0)
wStr.append(WIDE_("' SECOND"));
else
{
wStr.append(WIDE_("' SECOND TO "));
wStr.append(appendFraction(srcDesc->scale));
}
break;
}
// LCOV_EXCL_STOP
// LCOV_EXCL_START :rfi
default:
{
HS_ASSERT(FALSE);
break;
}
// LCOV_EXCL_STOP
}
target = wStr.data();
break;
}
case REC_INTERVAL:
{
//The INTERVAL may contain spaces and the negative sign
//in front of the number.
//We must capture the sign, but do not copy the extra character.
Int32 spaceLen = 0;
NABoolean signPresent = FALSE;
spaceLen = wcsspn(inData, L" ");
if (inData[spaceLen] == L'-')
{
signPresent = TRUE;
wStr = WIDE_("INTERVAL -'");
}
else
wStr = WIDE_("INTERVAL '");
for (short i=0; i < spaceLen; i++)
wStr.append(L" ");
wStr.append( (inData+((signPresent) ? 1 : 0)+spaceLen),
(inDataLen/sizeof(NAWchar)-((signPresent) ? 1 : 0)-spaceLen));
wStr.append(WIDE_("'"));
switch (srcDesc->datatype)
{
case REC_INT_YEAR:
{
na_wsprintf(workBuf, WIDE_("%s YEAR(%d)"), wStr.data(), srcDesc->precision);
break;
}
case REC_INT_YEAR_MONTH:
{
na_wsprintf(workBuf, WIDE_("%s YEAR(%d) TO MONTH"), wStr.data(), srcDesc->precision);
break;
}
case REC_INT_MONTH:
{
na_wsprintf(workBuf, WIDE_("%s MONTH(%d)"), wStr.data(), srcDesc->precision);
break;
}
case REC_INT_DAY:
{
na_wsprintf(workBuf, WIDE_("%s DAY(%d)"), wStr.data(), srcDesc->precision);
break;
}
case REC_INT_DAY_HOUR:
{
na_wsprintf(workBuf, WIDE_("%s DAY(%d) TO HOUR"), wStr.data(), srcDesc->precision);
break;
}
case REC_INT_DAY_MINUTE:
{
na_wsprintf(workBuf, WIDE_("%s DAY(%d) TO MINUTE"), wStr.data(), srcDesc->precision);
break;
}
case REC_INT_DAY_SECOND:
{
na_wsprintf(workBuf, WIDE_("%s DAY(%d) TO SECOND(%d)"), wStr.data(), srcDesc->precision, srcDesc->scale);
break;
}
case REC_INT_HOUR:
{
na_wsprintf(workBuf, WIDE_("%s HOUR(%d)"), wStr.data(), srcDesc->precision);
break;
}
case REC_INT_HOUR_MINUTE:
{
na_wsprintf(workBuf, WIDE_("%s HOUR(%d) TO MINUTE"), wStr.data(), srcDesc->precision);
break;
}
case REC_INT_HOUR_SECOND:
{
na_wsprintf(workBuf, WIDE_("%s HOUR(%d) TO SECOND(%d)"), wStr.data(), srcDesc->precision, srcDesc->scale);
break;
}
case REC_INT_MINUTE:
{
na_wsprintf(workBuf, WIDE_("%s MINUTE(%d)"), wStr.data(), srcDesc->precision);
break;
}
case REC_INT_MINUTE_SECOND:
{
na_wsprintf(workBuf, WIDE_("%s MINUTE(%d) TO SECOND(%d)"), wStr.data(), srcDesc->precision, srcDesc->scale);
break;
}
case REC_INT_SECOND:
{
na_wsprintf(workBuf, WIDE_("%s SECOND(%d, %d)"), wStr.data(), srcDesc->precision, srcDesc->scale);
break;
}
// LCOV_EXCL_START :rfi
default:
{
HS_ASSERT(FALSE);
break;
}
// LCOV_EXCL_STOP
}
target = workBuf;
break;
}
default:
{
wStr.replace(0, wStr.length(), inData, inDataLen/sizeof(NAWchar));
target = wStr.data();
break;
}
}
}
return retcode;
}
// -----------------------------------------------------------------------
// Add the single-column groups from startColumn to endColumn. If these
// parameters are NULL, the function has been called for the ON EVERY COLUMN
// clause, and we will add all single column groups, as well as key groups.
// -----------------------------------------------------------------------
Lng32 AddEveryColumn(const char *startColumn, const char *endColumn)
{
HSGlobalsClass *hs_globals = GetHSContext();
Lng32 colNumber, retcode;
NAString colName;
Lng32 start, upto;
HSLogMan *LM = HSLogMan::Instance();
hs_globals->parserError = HSGlobalsClass::ERROR_SEMANTICS;
// Can't use EVERYCOL_OPT flag for this test, it may have been set on a
// previous call (making this a redundant, or incorrect, request to ustat
// an individual column name). startColumn will always be NULL if this fn
// is called to add all the columns for a table.
if (!startColumn)
{
HS_ASSERT(hs_globals->optFlags & EVERYCOL_OPT);
start = 0;
upto = hs_globals->objDef->getNumCols() - 1;
}
else
{
start = hs_globals->objDef->getColNum(startColumn);
// LCOV_EXCL_START :rfi
if (start < 0)
{
retcode = -1;
HSHandleError(retcode);
}
// LCOV_EXCL_STOP
upto = hs_globals->objDef->getColNum(endColumn);
// LCOV_EXCL_START :rfi
if (upto < 0)
{
retcode = -1;
HSHandleError(retcode);
}
// LCOV_EXCL_STOP
if (start > upto)
{
Lng32 tmp = upto;
upto = start;
start = tmp;
}
}
for (colNumber = start; colNumber <= upto; colNumber++)
{
if (ColumnExists(colNumber)) // avoid duplicates
{
colName = hs_globals->objDef->getColName(colNumber);
if (LM->LogNeeded())
{
sprintf(LM->msg, "\t\t****Duplicate Column group (%s) has been ignored", colName.data());
LM->Log(LM->msg);
}
}
else // add to single-column group list
{
retcode = AddSingleColumn(colNumber);
}
}
if (!startColumn && // ON EVERY COLUMN causes key groups to be added as well
!HSGlobalsClass::isHiveCat(hs_globals->objDef->getCatName())) // No ustat on keys yet for hive tables
{
retcode = AddKeyGroups();
HSHandleError(retcode);
}
hs_globals->parserError = HSGlobalsClass::ERROR_SYNTAX;
return 0;
}
