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

MCOL-641 Refactor empty value implementation in writeengine.

Browse Source
This commit is contained in:
Gagan Goel
2020-03-02 13:23:07 -05:00
committed by Roman Nozdrin
parent 97ee1609b2
commit 824615a55b
31 changed files with 418 additions and 812 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
dbcon/mysql/ha_mcs_impl.cpp
View File

@ -1608,7 +1608,9 @@ uint32_t doUpdateDelete(THD* thd, gp_walk_info& gwi, const std::vector<COND*>& c
}
// Exit early if there is nothing to update
if (colAssignmentListPtr->empty())
if (colAssignmentListPtr->empty() &&
(((thd->lex)->sql_command == SQLCOM_UPDATE) ||
((thd->lex)->sql_command == SQLCOM_UPDATE_MULTI)))
{
ci->affectedRows = 0;
return 0;

5
primitives/linux-port/column.cpp
View File

@ -1537,11 +1537,6 @@ inline void p_Col_ridArray(NewColRequestHeader* in,
#endif
}
// WIP MCOL-641
using uint128_t = unsigned __int128;
using int128_t = __int128;
// for BINARY
template<int W>
inline void p_Col_bin_ridArray(NewColRequestHeader* in,

126
primitives/primproc/columncommand.cpp
View File

@ -48,6 +48,8 @@ using namespace rowgroup;
#include "messageids.h"
using namespace logging;
#include "emptyvaluemanip.h"
#ifdef _MSC_VER
#define llabs labs
#endif
@ -193,28 +195,34 @@ void ColumnCommand::loadData()
{
if (bPtr && colType.colWidth == 1)
{
ByteStream::byte b = getEmptyRowValue(colType.colDataType, colType.colWidth);
ByteStream::byte b;
utils::getEmptyRowValue(colType.colDataType, colType.colWidth, (uint8_t*)&b);
bPtr[idx] = b;
}
//@Bug 1812. Added two bytes column handling
else if (dPtr && colType.colWidth == 2)
{
ByteStream::doublebyte d = getEmptyRowValue(colType.colDataType, colType.colWidth);
ByteStream::doublebyte d;
utils::getEmptyRowValue(colType.colDataType, colType.colWidth, (uint8_t*)&d);
dPtr[idx] = d;
}
else if (qPtr && colType.colWidth == 4)
{
ByteStream::quadbyte q = getEmptyRowValue(colType.colDataType, colType.colWidth);
ByteStream::quadbyte q;
utils::getEmptyRowValue(colType.colDataType, colType.colWidth, (uint8_t*)&q);
qPtr[idx] = q;
}
else if (oPtr && colType.colWidth == 8)
{
ByteStream::octbyte o = getEmptyRowValue(colType.colDataType, colType.colWidth);
ByteStream::octbyte o;
utils::getEmptyRowValue(colType.colDataType, colType.colWidth, (uint8_t*)&o);
oPtr[idx] = o;
}
else if (colType.colWidth == 16)
{
getEmptyRowValue(colType.colDataType, colType.colWidth, &hPtr[idx]);
ByteStream::hexbyte h;
utils::getEmptyRowValue(colType.colDataType, colType.colWidth, (uint8_t*)&h);
hPtr[idx] = h;
}
}
@ -959,114 +967,6 @@ void ColumnCommand::enableFilters()
prep(primMsg->OutputType, makeAbsRids);
}
/***********************************************************
* DESCRIPTION:
* Get the value that represents empty row
* PARAMETERS:
* dataType - data type
* width - data width in byte
* RETURN:
* emptyVal - the value of empty row
***********************************************************/
const uint64_t ColumnCommand::getEmptyRowValue( const CSCDataType dataType, const int width ) const
{
uint64_t emptyVal = 0;
int offset;
offset = ( dataType == execplan::CalpontSystemCatalog::VARCHAR ) ? -1 : 0;
switch ( dataType )
{
case execplan::CalpontSystemCatalog::TINYINT :
emptyVal = joblist::TINYINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::SMALLINT:
emptyVal = joblist::SMALLINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::MEDINT :
case execplan::CalpontSystemCatalog::INT :
emptyVal = joblist::INTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::BIGINT :
emptyVal = joblist::BIGINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::UTINYINT :
emptyVal = joblist::UTINYINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::USMALLINT:
emptyVal = joblist::USMALLINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::UMEDINT :
case execplan::CalpontSystemCatalog::UINT :
emptyVal = joblist::UINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::UBIGINT :
emptyVal = joblist::UBIGINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::FLOAT :
case execplan::CalpontSystemCatalog::UFLOAT :
emptyVal = joblist::FLOATEMPTYROW;
break;
case execplan::CalpontSystemCatalog::DOUBLE :
case execplan::CalpontSystemCatalog::UDOUBLE :
emptyVal = joblist::DOUBLEEMPTYROW;
break;
case execplan::CalpontSystemCatalog::DECIMAL :
case execplan::CalpontSystemCatalog::UDECIMAL :
if ( width <= 1 )
emptyVal = joblist::TINYINTEMPTYROW;
else if (width <= 2)
emptyVal = joblist::SMALLINTEMPTYROW;
else if ( width <= 4 )
emptyVal = joblist::INTEMPTYROW;
else
emptyVal = joblist::BIGINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::CHAR :
case execplan::CalpontSystemCatalog::VARCHAR :
case execplan::CalpontSystemCatalog::DATE :
case execplan::CalpontSystemCatalog::DATETIME :
case execplan::CalpontSystemCatalog::TIMESTAMP :
case execplan::CalpontSystemCatalog::TIME :
case execplan::CalpontSystemCatalog::VARBINARY :
case execplan::CalpontSystemCatalog::BLOB :
case execplan::CalpontSystemCatalog::TEXT :
default:
emptyVal = joblist::CHAR1EMPTYROW;
if ( width == (2 + offset) )
emptyVal = joblist::CHAR2EMPTYROW;
else if ( width >= (3 + offset) && width <= ( 4 + offset ) )
emptyVal = joblist::CHAR4EMPTYROW;
else if ( width >= (5 + offset) )
emptyVal = joblist::CHAR8EMPTYROW;
break;
}
return emptyVal;
}
void ColumnCommand::getEmptyRowValue(const CSCDataType dataType,
const int width, messageqcpp::ByteStream::hexbyte* space) const
{
int128_t *val = reinterpret_cast<int128_t*>(space);
utils::setWideDecimalEMptyValue(*val);
}
void ColumnCommand::getLBIDList(uint32_t loopCount, vector<int64_t>* lbids)
{
int64_t firstLBID = lbid, lastLBID = firstLBID + (loopCount * colType.colWidth) - 1, i;

3
primitives/primproc/columncommand.h
View File

@ -84,9 +84,6 @@ public:
makeAbsRids = m;
}
bool willPrefetch();
const uint64_t getEmptyRowValue( const CSCDataType dataType, const int width ) const;
void getEmptyRowValue(const CSCDataType dataType,
const int width, messageqcpp::ByteStream::hexbyte* space) const;
const int64_t getLastLbid();
void getLBIDList(uint32_t loopCount, std::vector<int64_t>* lbids);

2
primitives/primproc/passthrucommand.cpp
View File

@ -167,7 +167,7 @@ void PassThruCommand::projectIntoRowGroup(RowGroup& rg, uint32_t col)
<< *(((int64_t*) bpp->values[i]) +1)
<< endl;
// values[i] is 8 bytes so it contains the pointer to bpp->outputMsg set by ColumnCommand::process_OT_BOTH()
r.setBinaryField_offset((uint8_t*)bpp->values[i], 16, offset);
r.setBinaryField_offset((uint128_t*)bpp->values[i], 16, offset);
r.nextRow(rowSize);
}

3
utils/common/CMakeLists.txt
View File

@ -10,7 +10,8 @@ set(common_LIB_SRCS
MonitorProcMem.cpp
nullvaluemanip.cpp
threadnaming.cpp
utils_utf8.cpp)
utils_utf8.cpp
emptyvaluemanip.cpp)
add_library(common SHARED ${common_LIB_SRCS})

115
utils/common/emptyvaluemanip.cpp Normal file
View File

@ -0,0 +1,115 @@
/* Copyright (C) 2020 MariaDB Corporation
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2 of
the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
#include "widedecimalutils.h"
#include "emptyvaluemanip.h"
namespace utils
{
void getEmptyRowValue(const execplan::CalpontSystemCatalog::ColDataType colDataType,
const int width, uint8_t* emptyVal)
{
switch (colDataType)
{
case execplan::CalpontSystemCatalog::TINYINT:
*(uint8_t*)emptyVal = joblist::TINYINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::SMALLINT:
*(uint16_t*)emptyVal = joblist::SMALLINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::MEDINT:
case execplan::CalpontSystemCatalog::INT:
*(uint32_t*)emptyVal = joblist::INTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::BIGINT:
*(uint64_t*)emptyVal = joblist::BIGINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::UTINYINT:
*(uint8_t*)emptyVal = joblist::UTINYINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::USMALLINT:
*(uint16_t*)emptyVal = joblist::USMALLINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::UMEDINT:
case execplan::CalpontSystemCatalog::UINT:
*(uint32_t*)emptyVal = joblist::UINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::UBIGINT:
*(uint64_t*)emptyVal = joblist::UBIGINTEMPTYROW;
break;
case execplan::CalpontSystemCatalog::FLOAT:
case execplan::CalpontSystemCatalog::UFLOAT:
*(uint32_t*)emptyVal = joblist::FLOATEMPTYROW;
break;
case execplan::CalpontSystemCatalog::DOUBLE:
case execplan::CalpontSystemCatalog::UDOUBLE:
*(uint64_t*)emptyVal = joblist::DOUBLEEMPTYROW;
break;
case execplan::CalpontSystemCatalog::DECIMAL:
case execplan::CalpontSystemCatalog::UDECIMAL:
if (width <= 1)
*(uint8_t*)emptyVal = joblist::TINYINTEMPTYROW;
else if (width <= 2)
*(uint16_t*)emptyVal = joblist::SMALLINTEMPTYROW;
else if (width <= 4)
*(uint32_t*)emptyVal = joblist::INTEMPTYROW;
else if (width <= 8)
*(uint64_t*)emptyVal = joblist::BIGINTEMPTYROW;
else
setWideDecimalEmptyValue(*(reinterpret_cast<int128_t*>(emptyVal)));
break;
//case CalpontSystemCatalog::BINARY:
// emptyVal = joblist::BINARYEMPTYROW;
// break;
case execplan::CalpontSystemCatalog::CHAR:
case execplan::CalpontSystemCatalog::VARCHAR:
case execplan::CalpontSystemCatalog::DATE:
case execplan::CalpontSystemCatalog::DATETIME:
case execplan::CalpontSystemCatalog::TIMESTAMP:
case execplan::CalpontSystemCatalog::TIME:
case execplan::CalpontSystemCatalog::VARBINARY:
case execplan::CalpontSystemCatalog::BLOB:
case execplan::CalpontSystemCatalog::TEXT:
default:
*(uint8_t*)emptyVal = joblist::CHAR1EMPTYROW;
int offset = (colDataType == execplan::CalpontSystemCatalog::VARCHAR) ? -1 : 0;
if (width == (2 + offset))
*(uint16_t*)emptyVal = joblist::CHAR2EMPTYROW;
else if (width >= (3 + offset) && width <= (4 + offset))
*(uint32_t*)emptyVal = joblist::CHAR4EMPTYROW;
else if (width >= (5 + offset))
*(uint64_t*)emptyVal = joblist::CHAR8EMPTYROW;
break;
}
}
} // namespace utils

31
utils/common/emptyvaluemanip.h Normal file
View File

@ -0,0 +1,31 @@
/* Copyright (C) 2020 MariaDB Corporation
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2 of
the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
#ifndef EMPTY_VALUE_MANIP_H
#define EMPTY_VALUE_MANIP_H
#include "calpontsystemcatalog.h"
namespace utils
{
void getEmptyRowValue(const execplan::CalpontSystemCatalog::ColDataType colDataType,
const int width, uint8_t* emptyVal);
} // namespace utils
#endif // EMPTY_VALUE_MANIP_H

6
utils/common/widedecimalutils.h
View File

@ -18,6 +18,8 @@
#ifndef WIDE_DECIMAL_UTILS_H
#define WIDE_DECIMAL_UTILS_H
#include <cstdint>
using int128_t = __int128;
using uint128_t = unsigned __int128;
@ -48,7 +50,7 @@ namespace utils
ptr[1] = BINARYNULLVALUEHIGH;
}
inline void setWideDecimalEMptyValue(int128_t& val)
inline void setWideDecimalEmptyValue(int128_t& val)
{
uint64_t* ptr = reinterpret_cast<uint64_t*>(&val);
ptr[0] = BINARYEMPTYVALUELOW;
@ -62,7 +64,7 @@ namespace utils
ptr[1] = BINARYNULLVALUEHIGH;
}
inline void setWideDecimalEMptyValue(int128_t* val)
inline void setWideDecimalEmptyValue(int128_t* val)
{
uint64_t* ptr = reinterpret_cast<uint64_t*>(val);
ptr[0] = BINARYEMPTYVALUELOW;

6
utils/dataconvert/dataconvert.cpp
View File

@ -1920,6 +1920,12 @@ DataConvert::convertColumnData(const CalpontSystemCatalog::ColType& colType,
long long eightbyte = joblist::BIGINTNULL;
value = eightbyte;
}
else if (colType.colWidth == 16)
{
int128_t val;
utils::setWideDecimalNullValue(val);
value = val;
}
else
{
WriteEngine::Token nullToken;

7
writeengine/bulk/we_bulkload.cpp
View File

@ -563,9 +563,10 @@ int BulkLoad::preProcess( Job& job, int tableNo,
job.jobTableList[tableNo].colList[i].weType = curColStruct.colType;
// set width to correct column width
job.jobTableList[tableNo].colList[i].width = curColStruct.colWidth;
job.jobTableList[tableNo].colList[i].emptyVal = getEmptyRowValue(
job.jobTableList[tableNo].colList[i].dataType,
job.jobTableList[tableNo].colList[i].width );
getEmptyRowValue(
job.jobTableList[tableNo].colList[i].dataType,
job.jobTableList[tableNo].colList[i].width,
(uint8_t*)&job.jobTableList[tableNo].colList[i].emptyVal);
// check HWM for column file
rc = BRMWrapper::getInstance()->getDbRootHWMInfo( curJobCol.mapOid,

7
writeengine/bulk/we_colbuf.cpp
View File

@ -115,12 +115,13 @@ int ColumnBuffer::writeToFile(int startOffset, int writeSize, bool fillUpWEmptie
{
BlockOp blockOp;
newBuf = new unsigned char[BYTE_PER_BLOCK];
uint64_t EmptyValue = blockOp.getEmptyRowValue(fColInfo->column.dataType,
fColInfo->column.width);
uint8_t* emptyVal = (uint8_t*) alloca(fColInfo->column.width);
blockOp.getEmptyRowValue(fColInfo->column.dataType,
fColInfo->column.width, emptyVal);
::memcpy(static_cast<void *>(newBuf),
static_cast<const void *>(fBuffer + startOffset), writeSize);
blockOp.setEmptyBuf(newBuf + writeSize, BYTE_PER_BLOCK - writeSize,
EmptyValue, fColInfo->column.width);
emptyVal, fColInfo->column.width);
}
#ifdef PROFILE
Stats::startParseEvent(WE_STATS_WRITE_COL);

8
writeengine/bulk/we_colbufcompressed.cpp
View File

@ -132,7 +132,7 @@ int ColumnBufferCompressed::resetToBeCompressedColBuf(
BlockOp::setEmptyBuf( fToBeCompressedBuffer,
IDBCompressInterface::UNCOMPRESSED_INBUF_LEN,
fColInfo->column.emptyVal,
(uint8_t*)&fColInfo->column.emptyVal,
fColInfo->column.width );
if (fLog->isDebug( DEBUG_2 ))
@ -317,7 +317,7 @@ int ColumnBufferCompressed::writeToFile(int startOffset, int writeSize,
// Start over again loading a new to-be-compressed buffer
BlockOp::setEmptyBuf( fToBeCompressedBuffer,
IDBCompressInterface::UNCOMPRESSED_INBUF_LEN,
fColInfo->column.emptyVal,
(uint8_t*)&fColInfo->column.emptyVal,
fColInfo->column.width );
fToBeCompressedCapacity =
@ -628,7 +628,7 @@ int ColumnBufferCompressed::initToBeCompressedBuffer(long long& startFileOffset)
new unsigned char[IDBCompressInterface::UNCOMPRESSED_INBUF_LEN];
BlockOp::setEmptyBuf( fToBeCompressedBuffer,
IDBCompressInterface::UNCOMPRESSED_INBUF_LEN,
fColInfo->column.emptyVal,
(uint8_t*)&fColInfo->column.emptyVal,
fColInfo->column.width );
bNewBuffer = true;
}
@ -743,7 +743,7 @@ int ColumnBufferCompressed::initToBeCompressedBuffer(long long& startFileOffset)
{
BlockOp::setEmptyBuf( fToBeCompressedBuffer,
IDBCompressInterface::UNCOMPRESSED_INBUF_LEN,
fColInfo->column.emptyVal,
(uint8_t*)&fColInfo->column.emptyVal,
fColInfo->column.width );
}

2
writeengine/bulk/we_columninfo.cpp
View File

@ -895,7 +895,7 @@ int ColumnInfo::extendColumnOldExtent(
}
rc = colOp->expandAbbrevColumnExtent( pFile, dbRootNext,
column.emptyVal, column.width);
(uint8_t*)&column.emptyVal, column.width);
if (rc != NO_ERROR)
{

2
writeengine/bulk/we_columninfocompressed.cpp
View File

@ -540,7 +540,7 @@ int ColumnInfoCompressed::extendColumnOldExtent(
int rc = colOp->fillCompColumnExtentEmptyChunks(
curCol.dataFile.fid,
curCol.colWidth,
column.emptyVal,
(uint8_t*)&column.emptyVal,
curCol.dataFile.fDbRoot,
curCol.dataFile.fPartition,
curCol.dataFile.fSegment,

10
writeengine/server/we_dmlcommandproc.cpp
View File

@ -370,8 +370,6 @@ uint8_t WE_DMLCommandProc::processSingleInsert(messageqcpp::ByteStream& bs, std:
try
{
// WIP
// make convertColumnData a template
datavalue = DataConvert::convertColumnData(colType, indata, pushWarning, insertPkg.get_TimeZone(), isNULL, false, false);
}
catch (exception&)
@ -388,7 +386,7 @@ uint8_t WE_DMLCommandProc::processSingleInsert(messageqcpp::ByteStream& bs, std:
return rc;
}
if ( pushWarning)
if (pushWarning)
{
if (!isWarningSet)
isWarningSet = true;
@ -546,7 +544,7 @@ uint8_t WE_DMLCommandProc::processSingleInsert(messageqcpp::ByteStream& bs, std:
WErrorCodes ec;
err = ec.errorString(error);
}
else if ( error == ERR_BRM_VB_OVERFLOW )
else if (error == ERR_BRM_VB_OVERFLOW)
{
rc = dmlpackageprocessor::DMLPackageProcessor::VB_OVERFLOW_ERROR;
err = IDBErrorInfo::instance()->errorMsg(ERR_VERSIONBUFFER_OVERFLOW);
@ -561,9 +559,9 @@ uint8_t WE_DMLCommandProc::processSingleInsert(messageqcpp::ByteStream& bs, std:
}
std::map<uint32_t, uint32_t> oids;
std::vector<BRM::OID_t> oidsToFlush;
std::vector<BRM::OID_t> oidsToFlush;
for ( unsigned i = 0; i < colStructs.size(); i++)
for (unsigned i = 0; i < colStructs.size(); i++)
{
oids[colStructs[i].dataOid] = colStructs[i].dataOid;
oidsToFlush.push_back(colStructs[i].dataOid);

115
writeengine/shared/we_blockop.cpp
View File

@ -34,6 +34,8 @@
using namespace execplan;
#include "emptyvaluemanip.h"
namespace WriteEngine
{
@ -83,110 +85,10 @@ bool BlockOp::calculateRowId(
* emptyVal - the value of empty row
***********************************************************/
// TODO MCOL-641 Add support here
uint64_t BlockOp::getEmptyRowValue(
const CalpontSystemCatalog::ColDataType colDataType, const int width ) const
void BlockOp::getEmptyRowValue(
const CalpontSystemCatalog::ColDataType colDataType, const int width, uint8_t* emptyVal ) const
{
uint64_t emptyVal = 0;
int offset = 0;
switch ( colDataType )
{
case CalpontSystemCatalog::TINYINT :
emptyVal = joblist::TINYINTEMPTYROW;
break;
case CalpontSystemCatalog::SMALLINT:
emptyVal = joblist::SMALLINTEMPTYROW;
break;
case CalpontSystemCatalog::MEDINT :
case CalpontSystemCatalog::INT :
emptyVal = joblist::INTEMPTYROW;
break;
case CalpontSystemCatalog::BIGINT :
emptyVal = joblist::BIGINTEMPTYROW;
break;
case CalpontSystemCatalog::FLOAT :
case CalpontSystemCatalog::UFLOAT :
emptyVal = joblist::FLOATEMPTYROW;
break;
case CalpontSystemCatalog::DOUBLE :
case CalpontSystemCatalog::UDOUBLE :
emptyVal = joblist::DOUBLEEMPTYROW;
break;
case CalpontSystemCatalog::DECIMAL :
case CalpontSystemCatalog::UDECIMAL :
/* if( width <= 4 )
emptyVal = joblist::SMALLINTEMPTYROW;
else
if( width <= 9 )
emptyVal = 0x80000001;
else
if( width <= 18 )
emptyVal = 0x8000000000000001LL;
else
emptyVal = 0xFFFFFFFFFFFFFFFFLL;
*/
// @bug 194 use the correct logic in handling empty value for decimal
if (width <= 1)
emptyVal = joblist::TINYINTEMPTYROW;
else if ( width <= 2 )
emptyVal = joblist::SMALLINTEMPTYROW;
else if ( width <= 4 )
emptyVal = joblist::INTEMPTYROW;
else if ( width <= 8 )
emptyVal = joblist::BIGINTEMPTYROW;
else
emptyVal = joblist::BINARYEMPTYROW;
break;
case CalpontSystemCatalog::UTINYINT :
emptyVal = joblist::UTINYINTEMPTYROW;
break;
case CalpontSystemCatalog::USMALLINT:
emptyVal = joblist::USMALLINTEMPTYROW;
break;
case CalpontSystemCatalog::UMEDINT :
case CalpontSystemCatalog::UINT :
emptyVal = joblist::UINTEMPTYROW;
break;
case CalpontSystemCatalog::UBIGINT :
emptyVal = joblist::UBIGINTEMPTYROW;
break;
case CalpontSystemCatalog::BINARY :
emptyVal = joblist::BINARYEMPTYROW;
break;
case CalpontSystemCatalog::CHAR :
case CalpontSystemCatalog::VARCHAR :
case CalpontSystemCatalog::DATE :
case CalpontSystemCatalog::DATETIME :
case CalpontSystemCatalog::TIMESTAMP :
default:
offset = ( colDataType == CalpontSystemCatalog::VARCHAR ) ? -1 : 0;
emptyVal = joblist::CHAR1EMPTYROW;
if ( width == (2 + offset) )
emptyVal = joblist::CHAR2EMPTYROW;
else if ( width >= (3 + offset) && width <= ( 4 + offset ) )
emptyVal = joblist::CHAR4EMPTYROW;
else if ( width >= (5 + offset) )
emptyVal = joblist::CHAR8EMPTYROW;
break;
}
return emptyVal;
utils::getEmptyRowValue(colDataType, width, emptyVal);
}
/***********************************************************
@ -264,7 +166,7 @@ void BlockOp::resetBuf( unsigned char* buf, const int bufSize ) const
***********************************************************/
/* static */
void BlockOp::setEmptyBuf(
unsigned char* buf, const int bufSize, uint64_t emptyVal, const int width )
unsigned char* buf, const int bufSize, uint8_t* emptyVal, const int width )
{
const int ARRAY_COUNT = 128;
const int NBYTES_IN_ARRAY = width * ARRAY_COUNT;
@ -275,10 +177,9 @@ void BlockOp::setEmptyBuf(
// instead of individual values. This reduces the number of calls to
// memcpy().
int w = width > 8 ? 8: width;
for(uint8_t* pos = emptyValArray, * end = pos + NBYTES_IN_ARRAY; pos < end; pos += w) //FIXME for no loop
for(uint8_t* pos = emptyValArray, * end = pos + NBYTES_IN_ARRAY; pos < end; pos += width) //FIXME for no loop
{
memcpy(pos, &emptyVal, w);
memcpy(pos, emptyVal, width);
}
int countFull128 = (bufSize / width) / ARRAY_COUNT;

7
writeengine/shared/we_blockop.h
View File

@ -89,8 +89,9 @@ public:
/**
* @brief Get an empty row value
*/
EXPORT uint64_t getEmptyRowValue(const execplan::CalpontSystemCatalog::ColDataType colDataType,
const int width ) const;
EXPORT void getEmptyRowValue(const execplan::CalpontSystemCatalog::ColDataType colDataType,
const int width,
uint8_t* emptyVal ) const;
/**
* @brief Calculate row id
@ -116,7 +117,7 @@ public:
*/
EXPORT void static setEmptyBuf( unsigned char* buf,
const int bufSize,
uint64_t emptyVal, const int width );
uint8_t* emptyVal, const int width );
/**
* @brief Set a value in a buffer

3
writeengine/shared/we_bulkrollbackfile.cpp
View File

@ -306,7 +306,8 @@ void BulkRollbackFile::reInitTruncColumnExtent(
}
// Initialize the remainder of the extent after the HWM block
uint64_t emptyVal = fDbFile.getEmptyRowValue( colType, colWidth );
uint8_t* emptyVal = (uint8_t*) alloca(colWidth);
fDbFile.getEmptyRowValue( colType, colWidth, emptyVal );
int rc = fDbFile.reInitPartialColumnExtent( pFile,
startOffset,

3
writeengine/shared/we_bulkrollbackfilecompressed.cpp
View File

@ -374,7 +374,8 @@ void BulkRollbackFileCompressed::reInitTruncColumnExtent(
if (nBlocksToInit > 0)
{
uint64_t emptyVal = fDbFile.getEmptyRowValue( colType, colWidth );
uint8_t* emptyVal = (uint8_t*) alloca(colWidth);
fDbFile.getEmptyRowValue( colType, colWidth, emptyVal );
rc = fDbFile.reInitPartialColumnExtent( pFile,
(chunkPtrs[chunkIndex].first + restoredChunkLen),
nBlocksToInit,

5
writeengine/shared/we_chunkmanager.cpp
View File

@ -821,7 +821,8 @@ int ChunkManager::fetchChunkFromFile(IDBDataFile* pFile, int64_t id, ChunkData*&
void ChunkManager::initializeColumnChunk(char* buf, CompFileData* fileData)
{
int size = UNCOMPRESSED_CHUNK_SIZE;
uint64_t emptyVal = fFileOp->getEmptyRowValue(fileData->fColDataType, fileData->fColWidth);
uint8_t* emptyVal = (uint8_t*) alloca(fileData->fColWidth);
fFileOp->getEmptyRowValue(fileData->fColDataType, fileData->fColWidth, emptyVal);
fFileOp->setEmptyBuf((unsigned char*)buf, size, emptyVal, fileData->fColWidth);
}
@ -1342,7 +1343,7 @@ inline int ChunkManager::writeHeader_(CompFileData* fileData, int ptrSecSize)
// For the specified segment file (pFile), read in an abbreviated/compressed
// chunk extent, uncompress, and expand to a full chunk for a full extent.
//------------------------------------------------------------------------------
int ChunkManager::expandAbbrevColumnExtent(IDBDataFile* pFile, uint64_t emptyVal, int width)
int ChunkManager::expandAbbrevColumnExtent(IDBDataFile* pFile, uint8_t* emptyVal, int width)
{
map<IDBDataFile*, CompFileData*>::iterator i = fFilePtrMap.find(pFile);

2
writeengine/shared/we_chunkmanager.h
View File

@ -214,7 +214,7 @@ public:
void cleanUp(const std::map<FID, FID>& columOids);
// @brief Expand an initial column, not dictionary, extent to a full extent.
int expandAbbrevColumnExtent(IDBDataFile* pFile, uint64_t emptyVal, int width);
int expandAbbrevColumnExtent(IDBDataFile* pFile, uint8_t* emptyVal, int width);
// @brief Update column extent
int updateColumnExtent(IDBDataFile* pFile, int addBlockCount);

10
writeengine/shared/we_convertor.cpp
View File

@ -639,8 +639,6 @@ void Convertor::convertColType(ColStruct* curStruct)
break;
default:
// WIP replace with BINARY
//*internalType = WriteEngine::WR_INT128;
*internalType = WriteEngine::WR_BINARY;
break;
}
@ -710,14 +708,8 @@ void Convertor::convertColType(ColStruct* curStruct)
// check whether width is in sync with the requirement
*width = getCorrectRowWidth(dataType, *width);
// This is the patch for the decimal thing, override
// if (dataType == CalpontSystemCatalog::DECIMAL)
// {
// *internalType = *width <= 4 ?
// WriteEngine::WR_INT : WriteEngine::WR_LONGLONG;
// }
}
/*******************************************************************************
* DESCRIPTION:

22
writeengine/shared/we_fileop.cpp
View File

@ -161,7 +161,7 @@ int FileOp::createDir( const char* dirName, mode_t mode ) const
* ERR_FILE_CREATE if can not create the file
***********************************************************/
int FileOp::createFile( const char* fileName, int numOfBlock,
uint64_t emptyVal, int width,
uint8_t* emptyVal, int width,
uint16_t dbRoot )
{
IDBDataFile* pFile =
@ -228,7 +228,7 @@ int FileOp::createFile(FID fid,
uint16_t dbRoot,
uint32_t partition,
execplan::CalpontSystemCatalog::ColDataType colDataType,
uint64_t emptyVal,
uint8_t* emptyVal,
int width)
{
//std::cout << "Creating file oid: " << fid <<
@ -569,7 +569,7 @@ bool FileOp::existsOIDDir( FID fid ) const
***********************************************************/
int FileOp::extendFile(
OID oid,
uint64_t emptyVal,
uint8_t* emptyVal,
int width,
HWM hwm,
BRM::LBID_t startLbid,
@ -875,7 +875,7 @@ int FileOp::extendFile(
***********************************************************/
int FileOp::addExtentExactFile(
OID oid,
uint64_t emptyVal,
uint8_t* emptyVal,
int width,
int& allocSize,
uint16_t dbRoot,
@ -1045,7 +1045,7 @@ int FileOp::initColumnExtent(
IDBDataFile* pFile,
uint16_t dbRoot,
int nBlocks,
uint64_t emptyVal,
uint8_t* emptyVal,
int width,
bool bNewFile,
bool bExpandExtent,
@ -1225,7 +1225,7 @@ int FileOp::initAbbrevCompColumnExtent(
IDBDataFile* pFile,
uint16_t dbRoot,
int nBlocks,
uint64_t emptyVal,
uint8_t* emptyVal,
int width)
{
// Reserve disk space for optimized abbreviated extent
@ -1285,7 +1285,7 @@ int FileOp::writeInitialCompColumnChunk(
IDBDataFile* pFile,
int nBlocksAllocated,
int nRows,
uint64_t emptyVal,
uint8_t* emptyVal,
int width,
char* hdrs)
{
@ -1366,7 +1366,7 @@ int FileOp::writeInitialCompColumnChunk(
***********************************************************/
int FileOp::fillCompColumnExtentEmptyChunks(OID oid,
int colWidth,
uint64_t emptyVal,
uint8_t* emptyVal,
uint16_t dbRoot,
uint32_t partition,
uint16_t segment,
@ -1671,7 +1671,7 @@ int FileOp::fillCompColumnExtentEmptyChunks(OID oid,
***********************************************************/
int FileOp::expandAbbrevColumnChunk(
IDBDataFile* pFile,
uint64_t emptyVal,
uint8_t* emptyVal,
int colWidth,
const CompChunkPtr& chunkInPtr,
CompChunkPtr& chunkOutPtr )
@ -2036,7 +2036,7 @@ int FileOp::reInitPartialColumnExtent(
IDBDataFile* pFile,
long long startOffset,
int nBlocks,
uint64_t emptyVal,
uint8_t* emptyVal,
int width )
{
int rc = setFileOffset( pFile, startOffset, SEEK_SET );
@ -2845,7 +2845,7 @@ bool FileOp::isDiskSpaceAvail(const std::string& fileName, int nBlocks) const
int FileOp::expandAbbrevColumnExtent(
IDBDataFile* pFile, // FILE ptr to file where abbrev extent is to be expanded
uint16_t dbRoot, // The DBRoot of the file with the abbreviated extent
uint64_t emptyVal,// Empty value to be used in expanding the extent
uint8_t* emptyVal,// Empty value to be used in expanding the extent
int width ) // Width of the column (in bytes)
{
// Based on extent size, see how many blocks to add to fill the extent

22
writeengine/shared/we_fileop.h
View File

@ -92,7 +92,7 @@ public:
int& allocSize,
uint16_t dbRoot, uint32_t partition,
execplan::CalpontSystemCatalog::ColDataType colDataType,
uint64_t emptyVal = 0, int width = 1 ) ;
uint8_t* emptyVal, int width = 1 ) ;
/**
@ -100,7 +100,7 @@ public:
* Changed to public for UT.
*/
int createFile( const char* fileName, int fileSize,
uint64_t emptyVal, int width,
uint8_t* emptyVal, int width,
uint16_t dbRoot );
/**
@ -163,7 +163,7 @@ public:
EXPORT virtual int expandAbbrevColumnExtent(
IDBDataFile* pFile,
uint16_t dbRoot,
uint64_t emptyVal,
uint8_t* emptyVal,
int width );
/**
@ -198,7 +198,7 @@ public:
* @param hdrs (in/out) Contents of headers, if file is compressed.
* @return returns NO_ERROR if success.
*/
EXPORT int extendFile(OID oid, uint64_t emptyVal,
EXPORT int extendFile(OID oid, uint8_t* emptyVal,
int width,
HWM hwm,
BRM::LBID_t startLbid,
@ -226,7 +226,7 @@ public:
* @param newFile (out) Indicates if a new file was created for the extent
* @param hdrs (in/out) Contents of headers, if file is compressed.
*/
EXPORT int addExtentExactFile(OID oid, uint64_t emptyVal,
EXPORT int addExtentExactFile(OID oid, uint8_t* emptyVal,
int width,
int& allocSize,
uint16_t dbRoot,
@ -253,7 +253,7 @@ public:
*/
EXPORT int fillCompColumnExtentEmptyChunks(OID oid,
int colWidth,
uint64_t emptyVal,
uint8_t* emptyVal,
uint16_t dbRoot,
uint32_t partition,
uint16_t segment,
@ -433,7 +433,7 @@ public:
EXPORT int reInitPartialColumnExtent( IDBDataFile* pFile,
long long startOffset,
int nBlocks,
uint64_t emptyVal,
uint8_t* emptyVal,
int width );
/**
@ -497,7 +497,7 @@ public:
int initColumnExtent( IDBDataFile* pFile,
uint16_t dbRoot,
int nBlocks,
uint64_t emptyVal,
uint8_t* emptyVal,
int width,
bool bNewFile,
bool bExpandExtent,
@ -519,7 +519,7 @@ private:
FileOp& operator=(const FileOp& rhs);
int expandAbbrevColumnChunk( IDBDataFile* pFile,
uint64_t emptyVal,
uint8_t* emptyVal,
int colWidth,
const compress::CompChunkPtr& chunkInPtr,
compress::CompChunkPtr& chunkOutPt);
@ -527,7 +527,7 @@ private:
int initAbbrevCompColumnExtent( IDBDataFile* pFile,
uint16_t dbRoot,
int nBlocks,
uint64_t emptyVal,
uint8_t* emptyVal,
int width);
static void initDbRootExtentMutexes();
@ -536,7 +536,7 @@ private:
int writeInitialCompColumnChunk( IDBDataFile* pFile,
int nBlocksAllocated,
int nRows,
uint64_t emptyVal,
uint8_t* emptyVal,
int width,
char* hdrs);

3
writeengine/shared/we_type.h
View File

@ -57,6 +57,7 @@ typedef uint32_t FID; /** @brief File ID */
typedef uint64_t RID; /** @brief Row ID */
typedef uint32_t TxnID; /** @brief Transaction ID (New)*/
typedef uint32_t HWM; /** @brief high water mark */
typedef unsigned __int128 uint128_t;
/************************************************************************
* Type enumerations
@ -347,7 +348,7 @@ struct JobColumn /** @brief Job Column Structure */
execplan::CalpontSystemCatalog::ColDataType dataType; /** @brief column data type */
ColType weType; /** @brief write engine data type */
std::string typeName; /** @brief data type name */
uint64_t emptyVal; /** @brief default empty value */
uint128_t emptyVal; /** @brief default empty value */
int width; /** @brief column width; for a dictionary column, this is "eventually" the token width */
int definedWidth; /** @brief column width as defined in the table, used for non-dictionary strings */
int dctnryWidth; /** @brief dictionary width */

146
writeengine/wrapper/we_colop.cpp
View File

@ -45,6 +45,7 @@ using namespace execplan;
using namespace idbdatafile;
#include "emptyvaluemanip.h"
namespace WriteEngine
{
@ -54,6 +55,9 @@ struct RefcolInfo
unsigned numExtents;
};
using int128_t = __int128;
using uint128_t = unsigned __int128;
/**
* Constructor
*/
@ -126,10 +130,8 @@ int ColumnOp::allocRowId(const TxnID& txnid, bool useStartingExtent,
Column newCol;
unsigned char buf[BYTE_PER_BLOCK];
unsigned char* curVal;
int64_t emptyVal = getEmptyRowValue(column.colDataType, column.colWidth); // Seems is ok have it here and just once
// TODO MCOL-641 consolidate the emptyvalue logic
//__int128 bigEmptyVal;
//dataconvert::DataConvert::uint128Max(bigEmptyVal);
uint8_t* emptyVal = (uint8_t*) alloca(column.colWidth);
getEmptyRowValue(column.colDataType, column.colWidth, emptyVal);
if (useStartingExtent)
{
@ -190,10 +192,12 @@ int ColumnOp::allocRowId(const TxnID& txnid, bool useStartingExtent,
{
if (rc == ERR_FILE_EOF)
{
uint64_t emptyVal = getEmptyRowValue(column.colDataType, column.colWidth);
uint8_t* emptyVal = (uint8_t*) alloca(column.colWidth);
getEmptyRowValue(column.colDataType, column.colWidth, emptyVal);
setEmptyBuf(buf, BYTE_PER_BLOCK, emptyVal, column.colWidth);
RETURN_ON_ERROR(saveBlock(column.dataFile.pFile, buf, hwm));
} else
}
else
{
return rc;
}
@ -287,7 +291,8 @@ int ColumnOp::allocRowId(const TxnID& txnid, bool useStartingExtent,
if (newColStructList[i].fCompressionType > 0)
{
uint64_t emptyVal = getEmptyRowValue(newColStructList[i].colDataType, newColStructList[i].colWidth);
uint8_t* emptyVal = (uint8_t*) alloca(newColStructList[i].colWidth);
getEmptyRowValue(newColStructList[i].colDataType, newColStructList[i].colWidth, emptyVal);
string errorInfo;
rc = fileOp.fillCompColumnExtentEmptyChunks(newColStructList[i].dataOid, newColStructList[i].colWidth,
emptyVal, dbRoot, partition, segment, newHwm, segFile, errorInfo);
@ -313,7 +318,8 @@ int ColumnOp::allocRowId(const TxnID& txnid, bool useStartingExtent,
return rc;
}
uint64_t emptyVal = getEmptyRowValue(newColStructList[i].colDataType, newColStructList[i].colWidth);
uint8_t* emptyVal = (uint8_t*) alloca(newColStructList[i].colWidth);
getEmptyRowValue(newColStructList[i].colDataType, newColStructList[i].colWidth, emptyVal);
rc = fileOp.expandAbbrevColumnExtent( pFile, dbRoot, emptyVal, newColStructList[i].colWidth);
//set hwm for this extent.
fileOp.closeFile(pFile);
@ -385,7 +391,7 @@ int ColumnOp::allocRowId(const TxnID& txnid, bool useStartingExtent,
return rc;
//create corresponding dictionary files
if (newFile )
if (newFile)
{
boost::scoped_ptr<WriteEngineWrapper> we (new WriteEngineWrapper());
we->setTransId(txnid);
@ -406,7 +412,7 @@ int ColumnOp::allocRowId(const TxnID& txnid, bool useStartingExtent,
}
}
we->flushDataFiles(rc, txnid, columnOids );
we->flushDataFiles(rc, txnid, columnOids);
}
}
@ -490,10 +496,12 @@ int ColumnOp::allocRowId(const TxnID& txnid, bool useStartingExtent,
{
if (rc == ERR_FILE_EOF)
{
uint64_t emptyVal = getEmptyRowValue(newCol.colDataType, newCol.colWidth);
uint8_t* emptyVal = (uint8_t*) alloca(newCol.colWidth);
getEmptyRowValue(newCol.colDataType, newCol.colWidth, emptyVal);
setEmptyBuf(buf, BYTE_PER_BLOCK, emptyVal, newCol.colWidth);
RETURN_ON_ERROR(saveBlock(newCol.dataFile.pFile, buf, newHwm));
} else
}
else
{
return rc;
}
@ -531,10 +539,12 @@ int ColumnOp::allocRowId(const TxnID& txnid, bool useStartingExtent,
{
if (rc == ERR_FILE_EOF)
{
uint64_t emptyVal = getEmptyRowValue(newCol.colDataType, newCol.colWidth);
uint8_t* emptyVal = (uint8_t*) alloca(newCol.colWidth);
getEmptyRowValue(newCol.colDataType, newCol.colWidth, emptyVal);
setEmptyBuf(buf, BYTE_PER_BLOCK, emptyVal, newCol.colWidth);
RETURN_ON_ERROR(saveBlock(newCol.dataFile.pFile, buf, newHwm));
} else
}
else
{
return rc;
}
@ -641,10 +651,10 @@ int ColumnOp::createColumn(Column& column,
uint32_t partition)
{
int rc, newWidth, allocSize;
uint64_t emptyVal = 0;
int compressionType = column.compressionType;
setColParam(column, colNo, colWidth, colDataType, colType);
emptyVal = getEmptyRowValue(colDataType, colWidth);
uint8_t* emptyVal = (uint8_t*) alloca(colWidth);
getEmptyRowValue(colDataType, colWidth, emptyVal);
newWidth = getCorrectRowWidth(colDataType, colWidth);
column.dataFile.fid = dataFid;
column.dataFile.fDbRoot = dbRoot;
@ -677,8 +687,6 @@ int ColumnOp::fillColumn(const TxnID& txnid, Column& column, Column& refCol, voi
HWM colHwm = 0;
RID maxRowId = 0;
int size = sizeof(Token);
uint64_t emptyVal;
uint64_t refEmptyVal;
long long startColFbo = 0;
long long startRefColFbo = 0;
@ -713,8 +721,10 @@ int ColumnOp::fillColumn(const TxnID& txnid, Column& column, Column& refCol, voi
config.initConfigCache();
std::vector<uint16_t> rootList;
config.getRootIdList( rootList );
emptyVal = getEmptyRowValue(column.colDataType, column.colWidth);
refEmptyVal = getEmptyRowValue(refCol.colDataType, refCol.colWidth);
uint8_t* emptyVal = (uint8_t*) alloca(column.colWidth);
uint8_t* refEmptyVal = (uint8_t*) alloca(refCol.colWidth);
getEmptyRowValue(column.colDataType, column.colWidth, emptyVal);
getEmptyRowValue(refCol.colDataType, refCol.colWidth, refEmptyVal);
//find the dbroots which have rows for refrence column
unsigned int i = 0, k = 0;
@ -938,7 +948,7 @@ int ColumnOp::fillColumn(const TxnID& txnid, Column& column, Column& refCol, voi
while (refBufOffset > 0)
{
if (memcmp(&refColBuf[refBufOffset], &refEmptyVal, refCol.colWidth) != 0)
if (memcmp(&refColBuf[refBufOffset], refEmptyVal, refCol.colWidth) != 0)
{
maxRowId = maxRowId + (refBufOffset / refCol.colWidth);
break;
@ -999,7 +1009,7 @@ int ColumnOp::fillColumn(const TxnID& txnid, Column& column, Column& refCol, voi
while ((tmpBufOffset + refCol.colWidth) <= BYTE_PER_BLOCK)
{
if (memcmp(refColBuf + tmpBufOffset, &refEmptyVal, refCol.colWidth) != 0) //Find the number of nextVal needed.
if (memcmp(refColBuf + tmpBufOffset, refEmptyVal, refCol.colWidth) != 0) //Find the number of nextVal needed.
{
nexValNeeded++;
//memcpy(colBuf + colBufOffset, defaultVal, column.colWidth);
@ -1028,7 +1038,7 @@ int ColumnOp::fillColumn(const TxnID& txnid, Column& column, Column& refCol, voi
while (((refBufOffset + refCol.colWidth) <= BYTE_PER_BLOCK) &&
((colBufOffset + column.colWidth) <= BYTE_PER_BLOCK))
{
if (memcmp(refColBuf + refBufOffset, &refEmptyVal, refCol.colWidth) != 0) //Find the number of nextVal needed.
if (memcmp(refColBuf + refBufOffset, refEmptyVal, refCol.colWidth) != 0) //Find the number of nextVal needed.
{
memcpy(defaultVal, &nextVal, 8);
nextVal++;
@ -1085,7 +1095,7 @@ int ColumnOp::fillColumn(const TxnID& txnid, Column& column, Column& refCol, voi
while (((refBufOffset + refCol.colWidth) <= BYTE_PER_BLOCK) &&
((colBufOffset + column.colWidth) <= BYTE_PER_BLOCK))
{
if (memcmp(refColBuf + refBufOffset, &refEmptyVal, refCol.colWidth) != 0)
if (memcmp(refColBuf + refBufOffset, refEmptyVal, refCol.colWidth) != 0)
{
/*if (autoincrement)
{
@ -1097,8 +1107,7 @@ int ColumnOp::fillColumn(const TxnID& txnid, Column& column, Column& refCol, voi
}
else if (column.compressionType != 0) //@Bug 3866, fill the empty row value for compressed chunk
{
for(int b = 0, w = column.colWidth; b < column.colWidth; b += 8, w = 8) //FIXME for no loop!
memcpy(colBuf + colBufOffset + b, &emptyVal, w);
memcpy(colBuf + colBufOffset, emptyVal, column.colWidth);
dirty = true;
}
@ -1327,9 +1336,8 @@ int ColumnOp::extendColumn(
bool& newFile,
char* hdrs)
{
uint64_t emptyVal = 0;
emptyVal = getEmptyRowValue(column.colDataType, column.colWidth);
uint8_t* emptyVal = (uint8_t*) alloca(column.colWidth);
getEmptyRowValue(column.colDataType, column.colWidth, emptyVal);
int rc = extendFile(column.dataFile.fid,
emptyVal,
column.colWidth,
@ -1370,9 +1378,8 @@ int ColumnOp::addExtent(
int& allocSize,
char* hdrs)
{
uint64_t emptyVal = 0;
emptyVal = getEmptyRowValue(column.colDataType, column.colWidth);
uint8_t* emptyVal = (uint8_t*) alloca(column.colWidth);
getEmptyRowValue(column.colDataType, column.colWidth, emptyVal);
int rc = addExtentExactFile(column.dataFile.fid,
emptyVal,
column.colWidth,
@ -1400,7 +1407,8 @@ int ColumnOp::addExtent(
***********************************************************/
int ColumnOp::expandAbbrevExtent(const Column& column)
{
uint64_t emptyVal = getEmptyRowValue(column.colDataType, column.colWidth);
uint8_t* emptyVal = (uint8_t*) alloca(column.colWidth);
getEmptyRowValue(column.colDataType, column.colWidth, emptyVal);
int rc = expandAbbrevColumnExtent(column.dataFile.pFile,
column.dataFile.fDbRoot,
emptyVal,
@ -1456,33 +1464,30 @@ void ColumnOp::initColumn(Column& column) const
* RETURN:
* true if success, false otherwise
***********************************************************/
// It is called at just 4 places on allocRowId() but all the time inside extend scanning loops
// WIP Template this method
// TODO MCOL-641 Add support here.
inline bool ColumnOp::isEmptyRow(uint64_t* curVal, uint64_t emptyVal, const int colWidth)
inline bool ColumnOp::isEmptyRow(uint64_t* curVal, uint8_t* emptyVal, const int colWidth)
{
// colWidth is either 1, 2, 4, 8, or 16 (Convertor::getCorrectRowWidth)
switch(colWidth){
case 1:
return *(uint8_t*)curVal == emptyVal;
return *(uint8_t*)curVal == *(uint8_t*)emptyVal;
case 2:
return *(uint16_t*)curVal == emptyVal;
return *(uint16_t*)curVal == *(uint16_t*)emptyVal;
case 4:
return *(uint32_t*)curVal == emptyVal;
return *(uint32_t*)curVal == *(uint32_t*)emptyVal;
case 8:
return *curVal == emptyVal;
return *(uint64_t*)curVal == *(uint64_t*)emptyVal;
case 16:
return ((curVal[0] == emptyVal) && (curVal[1] == emptyVal));
return *(uint128_t*)curVal == *(uint128_t*)emptyVal;
case 32:
return ((curVal[0] == emptyVal) && (curVal[1] == emptyVal)
&& (curVal[2] == emptyVal) && (curVal[3] == emptyVal));
//case 32:
// return ((curVal[0] == emptyVal) && (curVal[1] == emptyVal)
// && (curVal[2] == emptyVal) && (curVal[3] == emptyVal));
}
// WIP
return false;
}
@ -1610,11 +1615,6 @@ void ColumnOp::setColParam(Column& column,
column.compressionType = compressionType;
}
// WIP
using int128_t = __int128;
using uint128_t = unsigned __int128;
/***********************************************************
* DESCRIPTION:
* Write row(s)
@ -1637,7 +1637,7 @@ int ColumnOp::writeRow(Column& curCol, uint64_t totalRow, const RID* rowIdArray,
bool bExit = false, bDataDirty = false;
void* pVal = 0;
char charTmpBuf[8];
uint64_t emptyVal;
uint8_t* emptyVal = (uint8_t*) alloca(curCol.colWidth);
int rc = NO_ERROR;
uint16_t rowsInBlock = BYTE_PER_BLOCK / curCol.colWidth;
@ -1734,9 +1734,7 @@ int ColumnOp::writeRow(Column& curCol, uint64_t totalRow, const RID* rowIdArray,
break;
case WriteEngine::WR_BINARY:
// WIP CSCCol type
pVal = &((uint128_t*) valArray)[i];
//pVal = (uint8_t*) valArray + i * curCol.colWidth;
if (!bDelete) pVal = &((int128_t*) valArray)[i];
break;
default :
@ -1744,11 +1742,10 @@ int ColumnOp::writeRow(Column& curCol, uint64_t totalRow, const RID* rowIdArray,
break;
}
// TODO MCOL-641 do we need support here?
if (bDelete)
{
emptyVal = getEmptyRowValue(curCol.colDataType, curCol.colWidth);
pVal = &emptyVal;
utils::getEmptyRowValue(curCol.colDataType, curCol.colWidth, emptyVal);
pVal = emptyVal;
}
// This is the write stuff
@ -1793,16 +1790,9 @@ int ColumnOp::writeRows(Column& curCol, uint64_t totalRow, const RIDList& ridLis
void* pVal = 0;
//void* pOldVal;
char charTmpBuf[8];
uint64_t emptyVal;
uint8_t* emptyVal;
int rc = NO_ERROR;
int w = 0, incr = 8;
if (curCol.colType == WriteEngine::WR_BINARY)
w = incr = curCol.colWidth;
else
w = curCol.colWidth > 8 ? 8 : curCol.colWidth;
while (!bExit)
{
curRowId = ridList[i];
@ -1903,26 +1893,12 @@ int ColumnOp::writeRows(Column& curCol, uint64_t totalRow, const RIDList& ridLis
}
else
{
if (curCol.colType != WriteEngine::WR_BINARY)
{
emptyVal = getEmptyRowValue(curCol.colDataType, curCol.colWidth);
pVal = &emptyVal;
}
else
{
// fix this
uint128_t bigEmptyVal;
emptyVal = getEmptyRowValue(curCol.colDataType, curCol.colWidth);
*(reinterpret_cast<uint64_t*>(&bigEmptyVal)) = emptyVal;
*(reinterpret_cast<uint64_t*>(&bigEmptyVal) + 1) = emptyVal;
//dataconvert::DataConvert::uint128Max(bigEmptyVal);
pVal = &bigEmptyVal;
}
emptyVal = (uint8_t*) alloca(curCol.colWidth);
getEmptyRowValue(curCol.colDataType, curCol.colWidth, emptyVal);
pVal = emptyVal;
}
// This is the write stuff
for (int b = 0; b < curCol.colWidth; b += incr) //FIXME for no loop
writeBufValue(dataBuf + dataBio + b, pVal, w);
writeBufValue(dataBuf + dataBio, pVal, curCol.colWidth);
i++;

2
writeengine/wrapper/we_colop.h
View File

@ -220,7 +220,7 @@ public:
/**
* @brief Check whether it is an empty row
*/
EXPORT virtual bool isEmptyRow(uint64_t* curVal, uint64_t emptyVal, const int colWidth);
EXPORT virtual bool isEmptyRow(uint64_t* curVal, uint8_t* emptyVal, const int colWidth);
/**
* @brief Check whether it is a valid column

2
writeengine/wrapper/we_colopcompress.cpp
View File

@ -191,7 +191,7 @@ int ColumnOpCompress1::flushFile(int rc, std::map<FID, FID>& columnOids)
int ColumnOpCompress1::expandAbbrevColumnExtent(
IDBDataFile* pFile, uint16_t dbRoot, uint64_t emptyVal, int width)
IDBDataFile* pFile, uint16_t dbRoot, uint8_t* emptyVal, int width)
{
// update the uncompressed initial chunk to full chunk
int rc = m_chunkManager->expandAbbrevColumnExtent(pFile, emptyVal, width);

2
writeengine/wrapper/we_colopcompress.h
View File

@ -111,7 +111,7 @@ public:
/**
* @brief virtual method in FileOp
*/
int expandAbbrevColumnExtent(IDBDataFile* pFile, uint16_t dbRoot, uint64_t emptyVal, int width);
int expandAbbrevColumnExtent(IDBDataFile* pFile, uint16_t dbRoot, uint8_t* emptyVal, int width);
/**
* @brief virtual method in ColumnOp

549
writeengine/wrapper/writeengine.cpp
View File

@ -168,7 +168,6 @@ int WriteEngineWrapper::checkValid(const TxnID& txnid, const ColStructList& colS
structListSize = colStructList.size() ;
valListSize = colValueList.size();
// if (colStructList.size() != colValueList.size())
if (structListSize != valListSize)
return ERR_STRUCT_VALUE_NOT_MATCH;
@ -400,16 +399,16 @@ void WriteEngineWrapper::convertValue(const execplan::CalpontSystemCatalog::ColT
}
break;
// WIP MCOL-641
case WriteEngine::WR_BINARY:
{
size = cscColType.colWidth;
if (cscColType.colDataType == CalpontSystemCatalog::DECIMAL)
if (cscColType.colDataType == CalpontSystemCatalog::DECIMAL ||
cscColType.colDataType == CalpontSystemCatalog::UDECIMAL)
{
int128_t val = boost::any_cast<int128_t>(data);
memcpy(value, &val, size);
}
else
else // for CalpontSystemCatalog::BINARY
{
char val = boost::any_cast<char>(data);
memcpy(value, &val, size);
@ -521,19 +520,19 @@ void WriteEngineWrapper::convertValue(const CalpontSystemCatalog::ColType& cscCo
((Token*)valArray)[pos] = boost::any_cast<Token>(data);
break;
// WIP MCOL-641
case WriteEngine::WR_BINARY:
if (cscColType.colDataType != CalpontSystemCatalog::DECIMAL)
{
curStr = boost::any_cast<string>(data);
// String length or column width?
memcpy((char*)valArray + pos * curStr.length(), curStr.c_str(), curStr.length());
}
else
size_t size = cscColType.colWidth;
if (cscColType.colDataType == CalpontSystemCatalog::DECIMAL ||
cscColType.colDataType == CalpontSystemCatalog::UDECIMAL)
{
int128_t val = boost::any_cast<int128_t>(data);
size_t size = cscColType.colWidth;
// WIP Why do we use memcpy here?
memcpy((uint8_t*)valArray+pos*size, &val, size);
memcpy((uint8_t*)valArray + pos * size, &val, size);
}
else // for CalpontSystemCatalog::BINARY
{
char val = boost::any_cast<char>(data);
memcpy((uint8_t*)valArray + pos * size, &val, size);
}
break;
@ -602,17 +601,19 @@ void WriteEngineWrapper::convertValue(const CalpontSystemCatalog::ColType& cscCo
case WriteEngine::WR_TOKEN:
data = ((Token*)valArray)[pos];
break;
// WIP
// WIP MCOL-641
case WriteEngine::WR_BINARY :
if (cscColType.colDataType == CalpontSystemCatalog::DECIMAL)
if (cscColType.colDataType == CalpontSystemCatalog::DECIMAL ||
cscColType.colDataType == CalpontSystemCatalog::UDECIMAL)
{
data = ((int128_t*)valArray)[pos];
}
else
else // for CalpontSystemCatalog::BINARY
{
// WIP do we need tmp here?
char *tmp = (char*) alloca (sizeof(char) * cscColType.colWidth);
memcpy(tmp, (char*)valArray + pos * cscColType.colWidth, cscColType.colWidth);
size_t size = cscColType.colWidth;
char *tmp = (char*) alloca (sizeof(char) * size);
memcpy(tmp, (uint8_t*)valArray + pos * size, size);
curStr = tmp;
data = curStr;
}
@ -778,7 +779,6 @@ int WriteEngineWrapper::deleteRow(const TxnID& txnid, const vector<CSCTypesList>
DctnryValueList dctnryValueList;
ColStructList colStructList;
CSCTypesList cscColTypeList;
uint64_t emptyVal;
int rc;
string tmpStr("");
vector<DctnryStructList> dctnryExtentsStruct;
@ -790,6 +790,8 @@ int WriteEngineWrapper::deleteRow(const TxnID& txnid, const vector<CSCTypesList>
setTransId(txnid);
unsigned numExtents = colExtentsStruct.size();
uint128_t emptyVal;
for (unsigned extent = 0; extent < numExtents; extent++)
{
colStructList = colExtentsStruct[extent];
@ -802,23 +804,21 @@ int WriteEngineWrapper::deleteRow(const TxnID& txnid, const vector<CSCTypesList>
cscColType = cscColTypeList[i];
Convertor::convertColType(&curColStruct);
if (curColStruct.colType == WriteEngine::WR_BINARY)
/*if (curColStruct.colType == WriteEngine::WR_BINARY)
{
uint128_t bigEmptyVal;
emptyVal = m_colOp[op(curColStruct.fCompressionType)]->
getEmptyRowValue(curColStruct.colDataType, curColStruct.colWidth);
*(reinterpret_cast<uint64_t*>(&bigEmptyVal)) = emptyVal;
*(reinterpret_cast<uint64_t*>(&bigEmptyVal) + 1) = emptyVal;
//dataconvert::DataConvert::uint128Max(bigEmptyVal);
curTuple.data = bigEmptyVal;
}
else
{
emptyVal = m_colOp[op(curColStruct.fCompressionType)]->
getEmptyRowValue(curColStruct.colDataType, curColStruct.colWidth);
{*/
m_colOp[op(curColStruct.fCompressionType)]->
getEmptyRowValue(curColStruct.colDataType, curColStruct.colWidth, (uint8_t*)&emptyVal);
curTuple.data = emptyVal;
}
//}
curTupleList.push_back(curTuple);
colValueList.push_back(curTupleList);
@ -850,6 +850,75 @@ int WriteEngineWrapper::deleteRow(const TxnID& txnid, const vector<CSCTypesList>
return rc;
}
inline void allocateValArray(void*& valArray, ColTupleList::size_type totalRow,
ColType colType, int colWidth)
{
valArray = calloc(totalRow, colWidth);
// TODO MCOL-641 is commenting out the switch statement below correct?
#if 0
switch (colType)
{
case WriteEngine::WR_INT:
case WriteEngine::WR_MEDINT:
valArray = (int*) calloc(sizeof(int), totalRow);
break;
case WriteEngine::WR_UINT:
case WriteEngine::WR_UMEDINT:
valArray = (uint32_t*) calloc(sizeof(uint32_t), totalRow);
break;
case WriteEngine::WR_VARBINARY : // treat same as char for now
case WriteEngine::WR_CHAR:
case WriteEngine::WR_BLOB:
case WriteEngine::WR_TEXT:
valArray = (char*) calloc(sizeof(char), totalRow * MAX_COLUMN_BOUNDARY);
break;
case WriteEngine::WR_FLOAT:
valArray = (float*) calloc(sizeof(float), totalRow);
break;
case WriteEngine::WR_DOUBLE:
valArray = (double*) calloc(sizeof(double), totalRow);
break;
case WriteEngine::WR_BYTE:
valArray = (char*) calloc(sizeof(char), totalRow);
break;
case WriteEngine::WR_UBYTE:
valArray = (uint8_t*) calloc(sizeof(uint8_t), totalRow);
break;
case WriteEngine::WR_SHORT:
valArray = (short*) calloc(sizeof(short), totalRow);
break;
case WriteEngine::WR_USHORT:
valArray = (uint16_t*) calloc(sizeof(uint16_t), totalRow);
break;
case WriteEngine::WR_LONGLONG:
valArray = (long long*) calloc(sizeof(long long), totalRow);
break;
case WriteEngine::WR_ULONGLONG:
valArray = (uint64_t*) calloc(sizeof(uint64_t), totalRow);
break;
case WriteEngine::WR_TOKEN:
valArray = (Token*) calloc(sizeof(Token), totalRow);
break;
case WriteEngine::WR_BINARY:
valArray = calloc(totalRow, colWidth);
break;
}
#endif
}
int WriteEngineWrapper::deleteBadRows(const TxnID& txnid, ColStructList& colStructs,
RIDList& ridList, DctnryStructList& dctnryStructList)
{
@ -889,69 +958,7 @@ int WriteEngineWrapper::deleteBadRows(const TxnID& txnid, ColStructList& colStru
throw std::runtime_error(oss.str());
}
switch (colStructs[i].colType)
{
case WriteEngine::WR_INT:
case WriteEngine::WR_MEDINT:
valArray = (int*) calloc(sizeof(int), 1);
break;
case WriteEngine::WR_UINT:
case WriteEngine::WR_UMEDINT:
valArray = (uint32_t*) calloc(sizeof(uint32_t), 1);
break;
case WriteEngine::WR_VARBINARY : // treat same as char for now
case WriteEngine::WR_CHAR:
case WriteEngine::WR_BLOB:
case WriteEngine::WR_TEXT:
valArray = (char*) calloc(sizeof(char), 1 * MAX_COLUMN_BOUNDARY);
break;
case WriteEngine::WR_FLOAT:
valArray = (float*) calloc(sizeof(float), 1);
break;
case WriteEngine::WR_DOUBLE:
valArray = (double*) calloc(sizeof(double), 1);
break;
case WriteEngine::WR_BYTE:
valArray = (char*) calloc(sizeof(char), 1);
break;
case WriteEngine::WR_UBYTE:
valArray = (uint8_t*) calloc(sizeof(uint8_t), 1);
break;
case WriteEngine::WR_SHORT:
valArray = (short*) calloc(sizeof(short), 1);
break;
case WriteEngine::WR_USHORT:
valArray = (uint16_t*) calloc(sizeof(uint16_t), 1);
break;
case WriteEngine::WR_LONGLONG:
valArray = (long long*) calloc(sizeof(long long), 1);
break;
case WriteEngine::WR_ULONGLONG:
valArray = (uint64_t*) calloc(sizeof(uint64_t), 1);
break;
case WriteEngine::WR_TOKEN:
valArray = (Token*) calloc(sizeof(Token), 1);
break;
case WriteEngine::WR_BINARY:
//case WriteEngine::WR_INT128:
// WIP use column width here
// remove all C-casts from above
valArray = calloc(1, 16);
break;
}
allocateValArray(valArray, 1, colStructs[i].colType, colStructs[i].colWidth);
rc = colOp->writeRows(curCol, ridList.size(), ridList, valArray, 0, true);
@ -3270,8 +3277,6 @@ int WriteEngineWrapper::insertColumnRec_Single(const TxnID& txnid,
printInputValue(colStructList, colValueList, ridList);
}
// end
//Convert data type and column width to write engine specific
for (i = 0; i < colStructList.size(); i++)
Convertor::convertColType(&colStructList[i]);
@ -3299,7 +3304,7 @@ int WriteEngineWrapper::insertColumnRec_Single(const TxnID& txnid,
//--------------------------------------------------------------------------
// allocate row id(s)
//--------------------------------------------------------------------------
curColStruct = colStructList[colId];
curColStruct = colStructList[colId];
colOp = m_colOp[op(curColStruct.fCompressionType)];
colOp->initColumn(curCol);
@ -3336,7 +3341,7 @@ int WriteEngineWrapper::insertColumnRec_Single(const TxnID& txnid,
oldHwm = hwm; //Save this info for rollback
//need to pass real dbRoot, partition, and segment to setColParam
colOp->setColParam(curCol, colId, curColStruct.colWidth, curColStruct.colDataType,
colOp->setColParam(curCol, colId, curColStruct.colWidth, curColStruct.colDataType,
curColStruct.colType, curColStruct.dataOid, curColStruct.fCompressionType,
dbRoot, partitionNum, segmentNum);
@ -3455,12 +3460,12 @@ int WriteEngineWrapper::insertColumnRec_Single(const TxnID& txnid,
// if totalRow == rowsLeft, then not adding rows to 1st extent, so skip it.
//--------------------------------------------------------------------------
// DMC-SHARED_NOTHING_NOTE: Is it safe to assume only part0 seg0 is abbreviated?
if ((colStructList[colId].fColPartition == 0) &&
(colStructList[colId].fColSegment == 0) &&
((totalRow - rowsLeft) > 0) &&
(rowIdArray[totalRow - rowsLeft - 1] >= (RID)INITIAL_EXTENT_ROWS_TO_DISK))
if ((colStructList[colId].fColPartition == 0) &&
(colStructList[colId].fColSegment == 0) &&
((totalRow - rowsLeft) > 0) &&
(rowIdArray[totalRow - rowsLeft - 1] >= (RID)INITIAL_EXTENT_ROWS_TO_DISK))
{
for (unsigned k=0; k<colStructList.size(); k++)
for (unsigned k=0; k<colStructList.size(); k++)
{
if (k == colId)
continue;
@ -3685,7 +3690,6 @@ int WriteEngineWrapper::insertColumnRec_Single(const TxnID& txnid,
lastRidNew = rowIdArray[totalRow - 1];
}
//cout << "rowid allocated is " << lastRid << endl;
//if a new extent is created, all the columns in this table should
//have their own new extent
@ -3716,9 +3720,6 @@ int WriteEngineWrapper::insertColumnRec_Single(const TxnID& txnid,
succFlag = colOp->calculateRowId(lastRid,
BYTE_PER_BLOCK / colWidth, colWidth, curFbo, curBio);
//cout << "insertcolumnrec oid:rid:fbo:hwm = " <<
//colStructList[i].dataOid << ":" << lastRid << ":" <<
//curFbo << ":" << hwm << endl;
if (succFlag)
{
if ((HWM)curFbo > oldHwm)
@ -3811,7 +3812,6 @@ int WriteEngineWrapper::insertColumnRec_Single(const TxnID& txnid,
}
}
//cout << "lbids size = " << lbids.size()<< endl;
if (lbids.size() > 0)
rc = BRMWrapper::getInstance()->markExtentsInvalid(lbids, colDataTypes);
@ -4516,68 +4516,7 @@ int WriteEngineWrapper::writeColumnRecords(const TxnID& txnid,
break;
}
switch (curColStruct.colType)
{
case WriteEngine::WR_INT:
case WriteEngine::WR_MEDINT:
valArray = (int*) calloc(sizeof(int), totalRow);
break;
case WriteEngine::WR_UINT:
case WriteEngine::WR_UMEDINT:
valArray = (uint32_t*) calloc(sizeof(uint32_t), totalRow);
break;
case WriteEngine::WR_VARBINARY : // treat same as char for now
case WriteEngine::WR_CHAR:
case WriteEngine::WR_BLOB:
case WriteEngine::WR_TEXT:
valArray = (char*) calloc(sizeof(char), totalRow * MAX_COLUMN_BOUNDARY);
break;
case WriteEngine::WR_FLOAT:
valArray = (float*) calloc(sizeof(float), totalRow);
break;
case WriteEngine::WR_DOUBLE:
valArray = (double*) calloc(sizeof(double), totalRow);
break;
case WriteEngine::WR_BYTE:
valArray = (char*) calloc(sizeof(char), totalRow);
break;
case WriteEngine::WR_UBYTE:
valArray = (uint8_t*) calloc(sizeof(uint8_t), totalRow);
break;
case WriteEngine::WR_SHORT:
valArray = (short*) calloc(sizeof(short), totalRow);
break;
case WriteEngine::WR_USHORT:
valArray = (uint16_t*) calloc(sizeof(uint16_t), totalRow);
break;
case WriteEngine::WR_LONGLONG:
valArray = (long long*) calloc(sizeof(long long), totalRow);
break;
case WriteEngine::WR_ULONGLONG:
valArray = (uint64_t*) calloc(sizeof(uint64_t), totalRow);
break;
case WriteEngine::WR_TOKEN:
valArray = (Token*) calloc(sizeof(Token), totalRow);
break;
// WIP MCOL-641
case WriteEngine::WR_BINARY:
// Use column width and remove all C-casts from above
valArray = calloc(totalRow, curColType.colWidth);
break;
}
allocateValArray(valArray, totalRow, curColStruct.colType, curColStruct.colWidth);
// convert values to valArray
bExcp = false;
@ -4679,16 +4618,11 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid,
StopWatch timer;
#endif
totalRow1 = colValueList[0].size();
totalRow2 = 0;
if (newColValueList.size() > 0)
{
totalRow1 = colValueList[0].size();
totalRow2 = newColValueList[0].size();
}
else
{
totalRow1 = colValueList[0].size();
totalRow2 = 0;
}
TableMetaData* aTbaleMetaData = TableMetaData::makeTableMetaData(tableOid);
@ -4763,74 +4697,10 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid,
// WIP We can allocate based on column size and not colType
// have to init the size here
valArray = calloc(totalRow1, colStructList[i].colWidth);
#if 0
switch (colStructList[i].colType)
{
// WIP we don't need type cast here only size
case WriteEngine::WR_INT:
case WriteEngine::WR_MEDINT:
valArray = (int*) calloc(sizeof(int), totalRow1);
break;
case WriteEngine::WR_UINT:
case WriteEngine::WR_UMEDINT:
valArray = (uint32_t*) calloc(sizeof(uint32_t), totalRow1);
break;
case WriteEngine::WR_VARBINARY : // treat same as char for now
case WriteEngine::WR_CHAR:
case WriteEngine::WR_BLOB:
case WriteEngine::WR_TEXT:
valArray = (char*) calloc(sizeof(char), totalRow1 * MAX_COLUMN_BOUNDARY);
break;
case WriteEngine::WR_FLOAT:
valArray = (float*) calloc(sizeof(float), totalRow1);
break;
case WriteEngine::WR_DOUBLE:
valArray = (double*) calloc(sizeof(double), totalRow1);
break;
case WriteEngine::WR_BYTE:
valArray = (char*) calloc(sizeof(char), totalRow1);
break;
case WriteEngine::WR_UBYTE:
valArray = (uint8_t*) calloc(sizeof(uint8_t), totalRow1);
break;
case WriteEngine::WR_SHORT:
valArray = (short*) calloc(sizeof(short), totalRow1);
break;
case WriteEngine::WR_USHORT:
valArray = (uint16_t*) calloc(sizeof(uint16_t), totalRow1);
break;
case WriteEngine::WR_LONGLONG:
valArray = (long long*) calloc(sizeof(long long), totalRow1);
break;
case WriteEngine::WR_ULONGLONG:
valArray = (uint64_t*) calloc(sizeof(uint64_t), totalRow1);
break;
case WriteEngine::WR_TOKEN:
valArray = (Token*) calloc(sizeof(Token), totalRow1);
break;
// WIP
case WriteEngine::WR_BINARY:
valArray = calloc(totalRow1, colStructList[i].colWidth);
break;
}
#endif
allocateValArray(valArray, totalRow1, colStructList[i].colType, colStructList[i].colWidth);
// convert values to valArray
// WIP
// Is this m_opType ever set to DELETE?
// WIP Is m_opType ever set to DELETE?
if (m_opType != DELETE)
{
bExcp = false;
@ -4857,7 +4727,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid,
}
#ifdef PROFILE
iimer.start("writeRow ");
timer.start("writeRow ");
#endif
rc = colOp->writeRow(curCol, totalRow1, firstPart, valArray);
#ifdef PROFILE
@ -4950,71 +4820,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid,
}
}
// have to init the size here
// TODO MCOL-641 is commenting out the switch statement below correct?
valArray = calloc(totalRow2, newColStructList[i].colWidth);
/*switch (newColStructList[i].colType)
{
case WriteEngine::WR_INT:
case WriteEngine::WR_MEDINT:
valArray = (int*) calloc(sizeof(int), totalRow2);
break;
case WriteEngine::WR_UINT:
case WriteEngine::WR_UMEDINT:
valArray = (uint32_t*) calloc(sizeof(uint32_t), totalRow2);
break;
case WriteEngine::WR_VARBINARY : // treat same as char for now
case WriteEngine::WR_CHAR:
case WriteEngine::WR_BLOB:
case WriteEngine::WR_TEXT:
valArray = (char*) calloc(sizeof(char), totalRow2 * MAX_COLUMN_BOUNDARY);
break;
case WriteEngine::WR_FLOAT:
valArray = (float*) calloc(sizeof(float), totalRow2);
break;
case WriteEngine::WR_DOUBLE:
valArray = (double*) calloc(sizeof(double), totalRow2);
break;
case WriteEngine::WR_BYTE:
valArray = (char*) calloc(sizeof(char), totalRow2);
break;
case WriteEngine::WR_UBYTE:
valArray = (uint8_t*) calloc(sizeof(uint8_t), totalRow2);
break;
case WriteEngine::WR_SHORT:
valArray = (short*) calloc(sizeof(short), totalRow2);
break;
case WriteEngine::WR_USHORT:
valArray = (uint16_t*) calloc(sizeof(uint16_t), totalRow2);
break;
case WriteEngine::WR_LONGLONG:
valArray = (long long*) calloc(sizeof(long long), totalRow2);
break;
case WriteEngine::WR_ULONGLONG:
valArray = (uint64_t*) calloc(sizeof(uint64_t), totalRow2);
break;
case WriteEngine::WR_TOKEN:
valArray = (Token*) calloc(sizeof(Token), totalRow2);
break;
case WriteEngine::WR_BINARY:
//case WriteEngine::WR_INT128:
// WIP
valArray = calloc(totalRow2, 16);
break;
}*/
allocateValArray(valArray, totalRow2, newColStructList[i].colType, newColStructList[i].colWidth);
// convert values to valArray
if (m_opType != DELETE)
@ -5131,71 +4937,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid,
}
}
// have to init the size here
// shared pointers or memory in a stack
// TODO MCOL-641 is commenting out the switch statement below correct?
valArray = calloc(totalRow1, colStructList[i].colWidth);
// WIP
/*switch (colStructList[i].colType)
{
case WriteEngine::WR_INT:
case WriteEngine::WR_MEDINT:
valArray = (int*) calloc(sizeof(int), totalRow1);
break;
case WriteEngine::WR_UINT:
case WriteEngine::WR_UMEDINT:
valArray = (uint32_t*) calloc(sizeof(uint32_t), totalRow1);
break;
case WriteEngine::WR_VARBINARY : // treat same as char for now
case WriteEngine::WR_CHAR:
case WriteEngine::WR_BLOB:
case WriteEngine::WR_TEXT:
valArray = (char*) calloc(sizeof(char), totalRow1 * MAX_COLUMN_BOUNDARY);
break;
case WriteEngine::WR_FLOAT:
valArray = (float*) calloc(sizeof(float), totalRow1);
break;
case WriteEngine::WR_DOUBLE:
valArray = (double*) calloc(sizeof(double), totalRow1);
break;
case WriteEngine::WR_BYTE:
valArray = (char*) calloc(sizeof(char), totalRow1);
break;
case WriteEngine::WR_UBYTE:
valArray = (uint8_t*) calloc(sizeof(uint8_t), totalRow1);
break;
case WriteEngine::WR_SHORT:
valArray = (short*) calloc(sizeof(short), totalRow1);
break;
case WriteEngine::WR_USHORT:
valArray = (uint16_t*) calloc(sizeof(uint16_t), totalRow1);
break;
case WriteEngine::WR_LONGLONG:
valArray = (long long*) calloc(sizeof(long long), totalRow1);
break;
case WriteEngine::WR_ULONGLONG:
valArray = (uint64_t*) calloc(sizeof(uint64_t), totalRow1);
break;
case WriteEngine::WR_TOKEN:
valArray = (Token*) calloc(sizeof(Token), totalRow1);
break;
case WriteEngine::WR_BINARY:
//case WriteEngine::WR_INT128:
valArray = calloc(colStructList[i].colWidth, totalRow1);
break;
}*/
allocateValArray(valArray, totalRow1, colStructList[i].colType, colStructList[i].colWidth);
// convert values to valArray
if (m_opType != DELETE)
@ -5415,9 +5157,8 @@ int WriteEngineWrapper::writeColumnRecBinary(const TxnID& txnid,
((uint16_t*)valArray)[j] = tmp16;
break;
case WriteEngine::WR_BINARY:
// WIP
//case WriteEngine::WR_INT128:
case WriteEngine::WR_BINARY:
((uint64_t*)valArray)[j] = curValue; //FIXME maybe
break;
@ -5565,9 +5306,8 @@ int WriteEngineWrapper::writeColumnRecBinary(const TxnID& txnid,
((uint16_t*)valArray)[j] = tmp16;
break;
case WriteEngine::WR_BINARY:
// WIP
//case WriteEngine::WR_INT128:
case WriteEngine::WR_BINARY:
((uint64_t*)valArray)[j] = curValue; // FIXME maybe
break;
}
@ -5786,64 +5526,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid,
break;
}
switch (curColStruct.colType)
{
case WriteEngine::WR_INT:
case WriteEngine::WR_MEDINT:
valArray = (int*) calloc(sizeof(int), 1);
break;
case WriteEngine::WR_UINT:
case WriteEngine::WR_UMEDINT:
valArray = (uint32_t*) calloc(sizeof(uint32_t), 1);
break;
case WriteEngine::WR_VARBINARY : // treat same as char for now
case WriteEngine::WR_CHAR:
case WriteEngine::WR_BLOB:
case WriteEngine::WR_TEXT:
valArray = (char*) calloc(sizeof(char), 1 * MAX_COLUMN_BOUNDARY);
break;
case WriteEngine::WR_FLOAT:
valArray = (float*) calloc(sizeof(float), 1);
break;
case WriteEngine::WR_DOUBLE:
valArray = (double*) calloc(sizeof(double), 1);
break;
case WriteEngine::WR_BYTE:
valArray = (char*) calloc(sizeof(char), 1);
break;
case WriteEngine::WR_UBYTE:
valArray = (uint8_t*) calloc(sizeof(uint8_t), 1);
break;
case WriteEngine::WR_SHORT:
valArray = (short*) calloc(sizeof(short), 1);
break;
case WriteEngine::WR_USHORT:
valArray = (uint16_t*) calloc(sizeof(uint16_t), 1);
break;
case WriteEngine::WR_LONGLONG:
valArray = (long long*) calloc(sizeof(long long), 1);
break;
case WriteEngine::WR_ULONGLONG:
valArray = (uint64_t*) calloc(sizeof(uint64_t), 1);
break;
case WriteEngine::WR_TOKEN:
valArray = (Token*) calloc(sizeof(Token), 1);
break;
case WriteEngine::WR_BINARY:
valArray = calloc(1, curColStruct.colWidth);
break;
}
allocateValArray(valArray, 1, curColStruct.colType, curColStruct.colWidth);
// convert values to valArray
if (m_opType != DELETE)