database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-07-30 19:23:07 +03:00
Code Activity

Merge branch 'develop-1.1' into 1.2-merge-up-20190111

Browse Source
This commit is contained in:
Andrew Hutchings
2019-01-11 20:16:38 +00:00
parent 6172e60896 63824fa1c2
commit ab74bec10b
4 changed files with 100 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
tools/cleartablelock/cleartablelock.cpp
View File

@ -650,6 +650,11 @@ int main(int argc, char** argv)
rc = execBulkRollbackReq( msgQueClts, pmList,
&brm, tInfo, tblName.toString(), rollbackOnly, errMsg );
BRM::TxnID txn;
txn.id = tInfo.ownerTxnID;
txn.valid = true;
brm.rolledback(txn);
if (rc != 0)
{
logFinalStatus( tblName.toString(), lockID, errMsg );

70
utils/windowfunction/windowfunctiontype.cpp
View File

@ -325,6 +325,28 @@ template<> void WindowFunctionType::setValue<string>(uint64_t i, string& t)
fRow.setStringField(t, i);
}
// MCOL-1676 Need a separate specialization for string now.
template<>
void WindowFunctionType::setValue<string>(int ct, int64_t b, int64_t e, int64_t c, string* v)
{
if (c != WF__BOUND_ALL)
b = e = c;
uint64_t i = fFieldIndex[0];
if (v == NULL)
v = (string*) getNullValueByType(ct, i);
for (int64_t j = b; j <= e; j++)
{
if (j % 1000 == 0 && fStep->cancelled())
break;
fRow.setData(getPointer((*fRowData)[j]));
setValue(i, *v);
}
}
template<typename T>
void WindowFunctionType::setValue(int ct, int64_t b, int64_t e, int64_t c, T* v)
{
@ -342,9 +364,55 @@ void WindowFunctionType::setValue(int ct, int64_t b, int64_t e, int64_t c, T* v)
break;
fRow.setData(getPointer((*fRowData)[j]));
// MCOL-1676 Set the data based on out column type (ct)
switch (ct)
{
case CalpontSystemCatalog::TINYINT:
case CalpontSystemCatalog::SMALLINT:
case CalpontSystemCatalog::MEDINT:
case CalpontSystemCatalog::INT:
case CalpontSystemCatalog::BIGINT:
case CalpontSystemCatalog::DECIMAL:
{
int64_t iv = *v;
setValue(i, iv);
break;
}
case CalpontSystemCatalog::UTINYINT:
case CalpontSystemCatalog::USMALLINT:
case CalpontSystemCatalog::UMEDINT:
case CalpontSystemCatalog::UINT:
case CalpontSystemCatalog::UBIGINT:
case CalpontSystemCatalog::UDECIMAL:
{
uint64_t uv = *v;
setValue(i, uv);
break;
}
case CalpontSystemCatalog::DOUBLE:
case CalpontSystemCatalog::UDOUBLE:
{
double dv = *v;
setValue(i, dv);
break;
}
case CalpontSystemCatalog::FLOAT:
case CalpontSystemCatalog::UFLOAT:
{
float fv = *v;
setValue(i, fv);
break;
}
default:
{
setValue(i, *v);
}
}
}
}
template<typename T>
void WindowFunctionType::implicit2T(uint64_t i, T& t, int s)
@ -476,8 +544,6 @@ template void WindowFunctionType::setValue<int64_t>(int, int64_t, int64_t, int64
template void WindowFunctionType::setValue<uint64_t>(int, int64_t, int64_t, int64_t, uint64_t*);
template void WindowFunctionType::setValue<float>(int, int64_t, int64_t, int64_t, float*);
template void WindowFunctionType::setValue<double>(int, int64_t, int64_t, int64_t, double*);
template void WindowFunctionType::setValue<string>(int, int64_t, int64_t, int64_t, string*);
void* WindowFunctionType::getNullValueByType(int ct, int pos)
{

1
writeengine/server/we_dmlcommandproc.cpp
View File

@ -2742,6 +2742,7 @@ uint8_t WE_DMLCommandProc::processUpdate(messageqcpp::ByteStream& bs,
boost::scoped_array<int> preBlkNums(new int[columnsUpdated.size()]);
boost::scoped_array<OID> oids(new OID[columnsUpdated.size()]);
BRMWrapper::setUseVb(true);
for (unsigned int j = 0; j < columnsUpdated.size(); j++)
{
//timer.start("lookupsyscat");

93
writeengine/shared/we_convertor.cpp
View File

@ -178,97 +178,38 @@ const std::string Convertor::int2Str(int val)
* converted long long for specified "field"
******************************************************************************/
/* static */
long long Convertor::convertDecimalString(
const char* field,
int fieldLength,
int scale)
{
long long llVal = 0;
long double dval = strtold(field, NULL);
long long ret = 0;
int nDigitsBeforeDecPt = 0;
int nDigitsAfterDecPt = 0;
long long roundUp = 0; //@bug 3405 round off decimal column values
// Determine the number of digits before and after the decimal point
char* posDecPt = (char*)memchr(field, '.', fieldLength);
// move scale digits to the left of the decimal point
for (int i = 0; i < scale; i++)
dval *= 10;
if (posDecPt)
{
nDigitsBeforeDecPt = posDecPt - field;
nDigitsAfterDecPt = fieldLength - nDigitsBeforeDecPt - 1;
//@bug 3405 round off decimal column values
// We look at the scale+1 digit to see if we need to round up.
if (nDigitsAfterDecPt > scale)
{
char roundOffDigit = *(posDecPt + 1 + scale);
// range check against int64
if (dval > LLONG_MAX || dval < LLONG_MIN)
errno = ERANGE;
if ( (roundOffDigit > '4') &&
(roundOffDigit <= '9') ) // round up
{
roundUp = 1;
// We can't just use the sign of llVal to determine whether to
// add +1 or -1, because if we read in -0.005 with scale 2, we
// end up parsing "-0.00", which yields 0; meaning we lose the
// sign. So better (though maybe slower) to look for any lead-
// ing negative sign in the input string.
for (int k = 0; k < fieldLength; k++)
{
if (!isspace(field[k]))
{
if (field[k] == '-')
roundUp = -1;
break;
}
}
}
}
}
else
{
nDigitsBeforeDecPt = fieldLength;
nDigitsAfterDecPt = 0;
}
// Strip out the decimal point by stringing together
// the digits before and after the decimal point.
char* data = (char*)alloca(nDigitsBeforeDecPt + scale + 1);
memcpy(data, field, nDigitsBeforeDecPt);
if (nDigitsAfterDecPt)
{
if (scale > nDigitsAfterDecPt)
memcpy(data + nDigitsBeforeDecPt,
field + nDigitsBeforeDecPt + 1,
nDigitsAfterDecPt);
else // (scale <= nDigitsAfterDecPt)
memcpy(data + nDigitsBeforeDecPt,
field + nDigitsBeforeDecPt + 1,
scale);
}
// Add on any necessary zero padding at the end
if (scale > nDigitsAfterDecPt)
{
memset(data + nDigitsBeforeDecPt + nDigitsAfterDecPt,
'0',
scale - nDigitsAfterDecPt);
}
data[nDigitsBeforeDecPt + scale] = '\0';
// Convert our constructed decimal string back to a long long
//@bug 1814 Force strtoll to use base 10
errno = 0;
llVal = strtoll(data, 0, 10);
//@bug 3405 round off decimal values
if ((roundUp) && (errno == 0))
llVal += roundUp;
ret = dval;
return llVal;
// get the fractional part of what's left & round ret up or down.
dval -= ret;
if (dval >= 0.5 && ret < LLONG_MAX)
++ret;
else if (dval <= -0.5 && ret > LLONG_MIN)
--ret;
return ret;
}
/*******************************************************************************