mirror of
https://github.com/mariadb-corporation/mariadb-columnstore-engine.git
synced 2025-06-06 08:21:01 +03:00
1026 lines
28 KiB
C++
1026 lines
28 KiB
C++
/* Copyright (C) 2014 InfiniDB, Inc.
|
|
|
|
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. */
|
|
|
|
//
|
|
// $Id: columncommand.cpp 2057 2013-02-13 17:00:10Z pleblanc $
|
|
// C++ Implementation: columncommand
|
|
//
|
|
// Description:
|
|
//
|
|
//
|
|
// Author: Patrick LeBlanc <pleblanc@calpont.com>, (C) 2008
|
|
// Copyright: See COPYING file that comes with this distribution
|
|
//
|
|
//
|
|
|
|
#include <unistd.h>
|
|
#include <sstream>
|
|
#include <map>
|
|
#include <cstdlib>
|
|
#include <cmath>
|
|
using namespace std;
|
|
|
|
#include "bpp.h"
|
|
#include "errorcodes.h"
|
|
#include "exceptclasses.h"
|
|
#include "primitiveserver.h"
|
|
#include "primproc.h"
|
|
#include "stats.h"
|
|
|
|
using namespace messageqcpp;
|
|
using namespace rowgroup;
|
|
|
|
#include "messageids.h"
|
|
using namespace logging;
|
|
|
|
#ifdef _MSC_VER
|
|
#define llabs labs
|
|
#endif
|
|
|
|
namespace primitiveprocessor
|
|
{
|
|
|
|
extern int noVB;
|
|
|
|
ColumnCommand::ColumnCommand() :
|
|
Command(COLUMN_COMMAND),
|
|
blockCount(0),
|
|
loadCount(0),
|
|
suppressFilter(false)
|
|
{
|
|
}
|
|
|
|
ColumnCommand::~ColumnCommand() { }
|
|
|
|
void ColumnCommand::_execute()
|
|
{
|
|
// cout << "CC: executing" << endl;
|
|
if (_isScan)
|
|
makeScanMsg();
|
|
else if (bpp->ridCount == 0) // this would cause a scan
|
|
{
|
|
blockCount += colType.colWidth;
|
|
return; // a step with no input rids does nothing
|
|
}
|
|
else
|
|
makeStepMsg();
|
|
|
|
issuePrimitive();
|
|
processResult();
|
|
|
|
// check if feeding a filtercommand
|
|
if (fFilterFeeder != NOT_FEEDER)
|
|
copyRidsForFilterCmd();
|
|
}
|
|
|
|
void ColumnCommand::execute()
|
|
{
|
|
if (fFilterFeeder == LEFT_FEEDER)
|
|
values = bpp->fFiltCmdValues[0].get();
|
|
else if (fFilterFeeder == RIGHT_FEEDER)
|
|
values = bpp->fFiltCmdValues[1].get();
|
|
else
|
|
values = bpp->values;
|
|
|
|
_execute();
|
|
}
|
|
|
|
void ColumnCommand::execute(int64_t* vals)
|
|
{
|
|
values = vals;
|
|
_execute();
|
|
}
|
|
|
|
void ColumnCommand::makeScanMsg()
|
|
{
|
|
/* Finish the NewColRequestHeader. */
|
|
|
|
/* XXXPAT: if there is a Command preceeding this one, it's a DictScan feeding tokens
|
|
which need to become filter elements. Can we handle that with this design?
|
|
Implement that later. */
|
|
|
|
primMsg->ism.Size = baseMsgLength;
|
|
primMsg->NVALS = 0;
|
|
primMsg->LBID = lbid;
|
|
primMsg->RidFlags = 0xFF;
|
|
|
|
// cout << "scanning lbid " << lbid << " colwidth = " << primMsg->DataSize <<
|
|
// " filterCount = " << filterCount << " outputType = " <<
|
|
// (int) primMsg->OutputType << endl;
|
|
}
|
|
|
|
void ColumnCommand::makeStepMsg()
|
|
{
|
|
memcpy(&inputMsg[baseMsgLength], bpp->relRids, bpp->ridCount << 1);
|
|
primMsg->RidFlags = bpp->ridMap;
|
|
primMsg->ism.Size = baseMsgLength + (bpp->ridCount << 1);
|
|
primMsg->NVALS = bpp->ridCount;
|
|
primMsg->LBID = lbid;
|
|
// cout << "lbid is " << lbid << endl;
|
|
}
|
|
|
|
void ColumnCommand::loadData()
|
|
{
|
|
uint32_t wasCached;
|
|
uint32_t blocksRead;
|
|
uint8_t _mask;
|
|
uint64_t oidLastLbid = 0;
|
|
bool lastBlockReached = false;
|
|
oidLastLbid = getLastLbid();
|
|
uint32_t blocksToLoad = 0;
|
|
BRM::LBID_t* lbids = (BRM::LBID_t*) alloca(8 * sizeof(BRM::LBID_t));
|
|
uint8_t** blockPtrs = (uint8_t**) alloca(8 * sizeof(uint8_t*));
|
|
int i;
|
|
|
|
|
|
_mask = mask;
|
|
// primMsg->RidFlags = 0xff; // disables selective block loading
|
|
//cout <<__FILE__ << "::issuePrimitive() o: " << getOID() << " l:" << primMsg->LBID << " ll: " << oidLastLbid << endl;
|
|
|
|
for (i = 0; i < colType.colWidth; ++i, _mask <<= shift)
|
|
{
|
|
|
|
if ((!lastBlockReached && _isScan) || (!_isScan && primMsg->RidFlags & _mask))
|
|
{
|
|
lbids[blocksToLoad] = primMsg->LBID + i;
|
|
blockPtrs[blocksToLoad] = &bpp->blockData[i * BLOCK_SIZE];
|
|
blocksToLoad++;
|
|
loadCount++;
|
|
}
|
|
else if (lastBlockReached && _isScan)
|
|
{
|
|
// fill remaining blocks with empty values when col scan
|
|
int blockLen = BLOCK_SIZE / colType.colWidth;
|
|
ByteStream::octbyte* oPtr = NULL;
|
|
ByteStream::quadbyte* qPtr = NULL;
|
|
ByteStream::byte* bPtr = NULL;
|
|
ByteStream::doublebyte* dPtr = NULL;
|
|
|
|
if (colType.colWidth == 1)
|
|
bPtr = reinterpret_cast<ByteStream::byte*>(&bpp->blockData[i * BLOCK_SIZE]);
|
|
|
|
//@Bug 1812. Added two bytes column handling
|
|
if (colType.colWidth == 2)
|
|
dPtr = reinterpret_cast<ByteStream::doublebyte*>(&bpp->blockData[i * BLOCK_SIZE]);
|
|
|
|
if (colType.colWidth == 4)
|
|
qPtr = reinterpret_cast<ByteStream::quadbyte*>(&bpp->blockData[i * BLOCK_SIZE]);
|
|
|
|
if (colType.colWidth == 8)
|
|
oPtr = reinterpret_cast<ByteStream::octbyte*>(&bpp->blockData[i * BLOCK_SIZE]);
|
|
|
|
for (int idx = 0; idx < blockLen; idx++)
|
|
{
|
|
if (bPtr && colType.colWidth == 1)
|
|
{
|
|
ByteStream::byte b = getEmptyRowValue(colType.colDataType, colType.colWidth);
|
|
bPtr[idx] = b;
|
|
}
|
|
//@Bug 1812. Added two bytes column handling
|
|
else if (dPtr && colType.colWidth == 2)
|
|
{
|
|
ByteStream::doublebyte d = getEmptyRowValue(colType.colDataType, colType.colWidth);
|
|
dPtr[idx] = d;
|
|
}
|
|
else if (qPtr && colType.colWidth == 4)
|
|
{
|
|
ByteStream::quadbyte q = getEmptyRowValue(colType.colDataType, colType.colWidth);
|
|
qPtr[idx] = q;
|
|
}
|
|
else if (oPtr && colType.colWidth == 8)
|
|
{
|
|
ByteStream::octbyte o = getEmptyRowValue(colType.colDataType, colType.colWidth);
|
|
oPtr[idx] = o;
|
|
}
|
|
}
|
|
|
|
}// else
|
|
|
|
if ( (primMsg->LBID + i) == oidLastLbid)
|
|
lastBlockReached = true;
|
|
|
|
blockCount++;
|
|
} // for
|
|
|
|
/* Do the load */
|
|
wasCached = primitiveprocessor::loadBlocks(lbids,
|
|
bpp->versionInfo,
|
|
bpp->txnID,
|
|
colType.compressionType,
|
|
blockPtrs,
|
|
&blocksRead,
|
|
bpp->LBIDTrace,
|
|
bpp->sessionID,
|
|
blocksToLoad,
|
|
&wasVersioned,
|
|
willPrefetch(),
|
|
&bpp->vssCache);
|
|
bpp->cachedIO += wasCached;
|
|
bpp->physIO += blocksRead;
|
|
bpp->touchedBlocks += blocksToLoad;
|
|
}
|
|
|
|
void ColumnCommand::issuePrimitive()
|
|
{
|
|
uint32_t resultSize;
|
|
|
|
loadData();
|
|
|
|
// cout << "issuing primitive for LBID " << primMsg->LBID << endl;
|
|
if (!suppressFilter)
|
|
bpp->pp.setParsedColumnFilter(parsedColumnFilter);
|
|
else
|
|
bpp->pp.setParsedColumnFilter(emptyFilter);
|
|
|
|
bpp->pp.p_Col(primMsg, outMsg, bpp->outMsgSize, (unsigned int*)&resultSize);
|
|
|
|
/* Update CP data, the PseudoColumn code should always be !_isScan. Should be safe
|
|
to leave this here for now. */
|
|
if (_isScan)
|
|
{
|
|
bpp->validCPData = (outMsg->ValidMinMax && !wasVersioned);
|
|
//if (wasVersioned && outMsg->ValidMinMax)
|
|
// cout << "CC: versioning overriding min max data\n";
|
|
bpp->lbidForCP = lbid;
|
|
bpp->maxVal = outMsg->Max;
|
|
bpp->minVal = outMsg->Min;
|
|
}
|
|
|
|
} // issuePrimitive()
|
|
|
|
void ColumnCommand::process_OT_BOTH()
|
|
{
|
|
uint64_t i, pos;
|
|
|
|
bpp->ridCount = outMsg->NVALS;
|
|
bpp->ridMap = outMsg->RidFlags;
|
|
// cout << "rid Count is " << bpp->ridCount << endl;
|
|
|
|
/* this is verbose and repetative to minimize the work per row */
|
|
switch (colType.colWidth)
|
|
{
|
|
case 8:
|
|
for (i = 0, pos = sizeof(NewColResultHeader); i < outMsg->NVALS; ++i)
|
|
{
|
|
if (makeAbsRids)
|
|
bpp->absRids[i] = *((uint16_t*) &bpp->outputMsg[pos]) + bpp->baseRid;
|
|
|
|
bpp->relRids[i] = *((uint16_t*) &bpp->outputMsg[pos]);
|
|
pos += 2;
|
|
values[i] = *((int64_t*) &bpp->outputMsg[pos]);
|
|
pos += 8;
|
|
}
|
|
|
|
break;
|
|
|
|
case 4:
|
|
for (i = 0, pos = sizeof(NewColResultHeader); i < outMsg->NVALS; ++i)
|
|
{
|
|
if (makeAbsRids)
|
|
bpp->absRids[i] = *((uint16_t*) &bpp->outputMsg[pos]) + bpp->baseRid;
|
|
|
|
bpp->relRids[i] = *((uint16_t*) &bpp->outputMsg[pos]);
|
|
pos += 2;
|
|
values[i] = *((int32_t*) &bpp->outputMsg[pos]);
|
|
pos += 4;
|
|
}
|
|
|
|
break;
|
|
|
|
case 2:
|
|
for (i = 0, pos = sizeof(NewColResultHeader); i < outMsg->NVALS; ++i)
|
|
{
|
|
if (makeAbsRids)
|
|
bpp->absRids[i] = *((uint16_t*) &bpp->outputMsg[pos]) + bpp->baseRid;
|
|
|
|
bpp->relRids[i] = *((uint16_t*) &bpp->outputMsg[pos]);
|
|
pos += 2;
|
|
values[i] = *((int16_t*) &bpp->outputMsg[pos]);
|
|
pos += 2;
|
|
}
|
|
|
|
break;
|
|
|
|
case 1:
|
|
for (i = 0, pos = sizeof(NewColResultHeader); i < outMsg->NVALS; ++i)
|
|
{
|
|
if (makeAbsRids)
|
|
bpp->absRids[i] = *((uint16_t*) &bpp->outputMsg[pos]) + bpp->baseRid;
|
|
|
|
bpp->relRids[i] = *((uint16_t*) &bpp->outputMsg[pos]);
|
|
pos += 2;
|
|
values[i] = *((int8_t*) &bpp->outputMsg[pos++]);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
void ColumnCommand::process_OT_RID()
|
|
{
|
|
memcpy(bpp->relRids, outMsg + 1, outMsg->NVALS << 1);
|
|
bpp->ridCount = outMsg->NVALS;
|
|
bpp->ridMap = outMsg->RidFlags;
|
|
// cout << "rid Count is " << bpp->ridCount << endl;
|
|
}
|
|
|
|
void ColumnCommand::process_OT_DATAVALUE()
|
|
{
|
|
bpp->ridCount = outMsg->NVALS;
|
|
|
|
// cout << "rid Count is " << bpp->ridCount << endl;
|
|
switch (colType.colWidth)
|
|
{
|
|
case 8:
|
|
{
|
|
memcpy(values, outMsg + 1, outMsg->NVALS << 3);
|
|
// cout << " CC: first value is " << values[0] << endl;
|
|
break;
|
|
}
|
|
|
|
case 4:
|
|
{
|
|
int32_t* arr32 = (int32_t*) (outMsg + 1);
|
|
|
|
for (uint64_t i = 0; i < outMsg->NVALS; ++i)
|
|
values[i] = arr32[i];
|
|
|
|
break;
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
int16_t* arr16 = (int16_t*) (outMsg + 1);
|
|
|
|
for (uint64_t i = 0; i < outMsg->NVALS; ++i)
|
|
values[i] = arr16[i];
|
|
|
|
break;
|
|
}
|
|
|
|
case 1:
|
|
{
|
|
int8_t* arr8 = (int8_t*) (outMsg + 1);
|
|
|
|
for (uint64_t i = 0; i < outMsg->NVALS; ++i)
|
|
values[i] = arr8[i];
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ColumnCommand::processResult()
|
|
{
|
|
/* Switch on output type, turn pCol output into something useful, store it in
|
|
the containing BPP */
|
|
|
|
// if (filterCount == 0 && !_isScan)
|
|
// idbassert(outMsg->NVALS == bpp->ridCount);
|
|
|
|
switch (outMsg->OutputType)
|
|
{
|
|
case OT_BOTH:
|
|
process_OT_BOTH();
|
|
break;
|
|
|
|
case OT_RID:
|
|
process_OT_RID();
|
|
break;
|
|
|
|
case OT_DATAVALUE:
|
|
process_OT_DATAVALUE();
|
|
break;
|
|
|
|
default:
|
|
cout << "outputType = " << outMsg->OutputType << endl;
|
|
throw logic_error("ColumnCommand got a bad OutputType");
|
|
}
|
|
|
|
// check if feeding a filtercommand
|
|
if (fFilterFeeder == LEFT_FEEDER)
|
|
{
|
|
bpp->fFiltRidCount[0] = bpp->ridCount;
|
|
|
|
for (uint64_t i = 0; i < bpp->ridCount; i++)
|
|
bpp->fFiltCmdRids[0][i] = bpp->relRids[i];
|
|
}
|
|
else if (fFilterFeeder == RIGHT_FEEDER)
|
|
{
|
|
bpp->fFiltRidCount[1] = bpp->ridCount;
|
|
|
|
for (uint64_t i = 0; i < bpp->ridCount; i++)
|
|
bpp->fFiltCmdRids[1][i] = bpp->relRids[i];
|
|
}
|
|
|
|
// cout << "processed " << outMsg->NVALS << " rows" << endl;
|
|
}
|
|
|
|
void ColumnCommand::createCommand(ByteStream& bs)
|
|
{
|
|
uint8_t tmp8;
|
|
|
|
bs.advance(1);
|
|
bs >> tmp8;
|
|
_isScan = tmp8;
|
|
bs >> traceFlags;
|
|
bs >> filterString;
|
|
#if 0
|
|
cout << "filter string: ";
|
|
|
|
for (uint32_t i = 0; i < filterString.length(); ++i)
|
|
cout << (int) filterString.buf()[i] << " ";
|
|
|
|
cout << endl;
|
|
#endif
|
|
bs >> tmp8;
|
|
colType.colDataType = (execplan::CalpontSystemCatalog::ColDataType) tmp8;
|
|
bs >> tmp8;
|
|
colType.colWidth = tmp8;
|
|
bs >> tmp8;
|
|
colType.scale = tmp8;
|
|
bs >> tmp8;
|
|
colType.compressionType = tmp8;
|
|
bs >> BOP;
|
|
bs >> filterCount;
|
|
deserializeInlineVector(bs, lastLbid);
|
|
// cout << "lastLbid count=" << lastLbid.size() << endl;
|
|
// for (uint32_t i = 0; i < lastLbid.size(); i++)
|
|
// cout << " " << lastLbid[i];
|
|
|
|
|
|
//cout << "CreateCommand() o:" << getOID() << " lastLbid: " << lastLbid << endl;
|
|
Command::createCommand(bs);
|
|
|
|
parsedColumnFilter = primitives::parseColumnFilter(filterString.buf(), colType.colWidth,
|
|
colType.colDataType, filterCount, BOP);
|
|
|
|
/* OR hack */
|
|
emptyFilter = primitives::parseColumnFilter(filterString.buf(), colType.colWidth,
|
|
colType.colDataType, 0, BOP);
|
|
|
|
/* XXXPAT: for debugging only */
|
|
// bs >> colType.columnOID;
|
|
// cout << "got filterCount " << filterCount << endl;
|
|
// cout << "made a ColumnCommand OID = " << OID << endl;
|
|
}
|
|
|
|
void ColumnCommand::resetCommand(ByteStream& bs)
|
|
{
|
|
bs >> lbid;
|
|
}
|
|
|
|
void ColumnCommand::prep(int8_t outputType, bool absRids)
|
|
{
|
|
/* make the template NewColRequestHeader */
|
|
|
|
baseMsgLength = sizeof(NewColRequestHeader) +
|
|
(suppressFilter ? 0 : filterString.length());
|
|
|
|
if (!inputMsg)
|
|
inputMsg.reset(new uint8_t[baseMsgLength + (LOGICAL_BLOCK_RIDS * 2)]);
|
|
|
|
primMsg = (NewColRequestHeader*) inputMsg.get();
|
|
outMsg = (NewColResultHeader*) bpp->outputMsg.get();
|
|
makeAbsRids = absRids;
|
|
|
|
primMsg->ism.Interleave = 0;
|
|
primMsg->ism.Flags = 0;
|
|
// primMsg->ism.Flags = PrimitiveMsg::planFlagsToPrimFlags(traceFlags);
|
|
primMsg->ism.Command = COL_BY_SCAN;
|
|
primMsg->ism.Size = sizeof(NewColRequestHeader) + (suppressFilter ? 0 : filterString.length());
|
|
primMsg->ism.Type = 2;
|
|
primMsg->hdr.SessionID = bpp->sessionID;
|
|
//primMsg->hdr.StatementID = 0;
|
|
primMsg->hdr.TransactionID = bpp->txnID;
|
|
primMsg->hdr.VerID = bpp->versionInfo.currentScn;
|
|
primMsg->hdr.StepID = bpp->stepID;
|
|
primMsg->DataSize = colType.colWidth;
|
|
primMsg->DataType = colType.colDataType;
|
|
primMsg->CompType = colType.compressionType;
|
|
primMsg->OutputType = outputType;
|
|
primMsg->BOP = BOP;
|
|
primMsg->NOPS = (suppressFilter ? 0 : filterCount);
|
|
primMsg->sort = 0;
|
|
#if 0
|
|
cout << "filter length is " << filterString.length() << endl;
|
|
|
|
cout << "appending filter string: ";
|
|
|
|
for (uint32_t i = 0; i < filterString.length(); ++i)
|
|
cout << (int) filterString.buf()[i] << " ";
|
|
|
|
cout << endl;
|
|
#endif
|
|
// made unnecessary by parsedColumnFilter, just leave empty space as if the filter
|
|
// were still there.
|
|
// memcpy(primMsg + 1, filterString.buf(), filterString.length());
|
|
|
|
|
|
|
|
switch (colType.colWidth)
|
|
{
|
|
case 1:
|
|
shift = 8;
|
|
mask = 0xFF;
|
|
break;
|
|
|
|
case 2:
|
|
shift = 4;
|
|
mask = 0x0F;
|
|
break;
|
|
|
|
case 4:
|
|
shift = 2;
|
|
mask = 0x03;
|
|
break;
|
|
|
|
case 8:
|
|
shift = 1;
|
|
mask = 0x01;
|
|
break;
|
|
|
|
default:
|
|
cout << "CC: colWidth is " << colType.colWidth << endl;
|
|
throw logic_error("ColumnCommand: bad column width?");
|
|
}
|
|
|
|
/* TODO: re-optimize with parameterized output RG */
|
|
// if (bpp->ot == ROW_GROUP) {
|
|
// bpp->outputRG.initRow(&r);
|
|
// rowSize = r.getSize();
|
|
// }
|
|
|
|
}
|
|
|
|
/* Assumes OT_DATAVALUE */
|
|
void ColumnCommand::projectResult()
|
|
{
|
|
if (primMsg->NVALS != outMsg->NVALS || outMsg->NVALS != bpp->ridCount )
|
|
{
|
|
ostringstream os;
|
|
BRM::DBRM brm;
|
|
BRM::OID_t oid;
|
|
uint16_t l_dbroot;
|
|
uint32_t partNum;
|
|
uint16_t segNum;
|
|
uint32_t fbo;
|
|
brm.lookupLocal(lbid, 0, false, oid, l_dbroot, partNum, segNum, fbo);
|
|
|
|
os << __FILE__ << " error on projection for oid " << oid << " lbid " << lbid;
|
|
|
|
if (primMsg->NVALS != outMsg->NVALS )
|
|
os << ": input rids " << primMsg->NVALS;
|
|
else
|
|
os << ": ridcount " << bpp->ridCount;
|
|
|
|
os << ", output rids " << outMsg->NVALS << endl;
|
|
|
|
//cout << os.str();
|
|
if (bpp->sessionID & 0x80000000)
|
|
throw NeedToRestartJob(os.str());
|
|
else
|
|
throw PrimitiveColumnProjectResultExcept(os.str());
|
|
}
|
|
|
|
idbassert(primMsg->NVALS == outMsg->NVALS);
|
|
idbassert(outMsg->NVALS == bpp->ridCount);
|
|
*bpp->serialized << (uint32_t) (outMsg->NVALS * colType.colWidth);
|
|
bpp->serialized->append((uint8_t*) (outMsg + 1), outMsg->NVALS * colType.colWidth);
|
|
}
|
|
|
|
void ColumnCommand::removeRowsFromRowGroup(RowGroup& rg)
|
|
{
|
|
uint32_t gapSize = colType.colWidth + 2;
|
|
uint8_t* msg8;
|
|
uint16_t rid;
|
|
Row oldRow, newRow;
|
|
uint32_t oldIdx, newIdx;
|
|
|
|
rg.initRow(&oldRow);
|
|
rg.initRow(&newRow);
|
|
rg.getRow(0, &oldRow);
|
|
rg.getRow(0, &newRow);
|
|
msg8 = (uint8_t*) (outMsg + 1);
|
|
|
|
for (oldIdx = newIdx = 0; newIdx < outMsg->NVALS; newIdx++, msg8 += gapSize)
|
|
{
|
|
rid = *((uint16_t*) msg8);
|
|
|
|
while (rid != bpp->relRids[oldIdx])
|
|
{
|
|
// need to find rid in relrids, and it is in there
|
|
oldIdx++;
|
|
oldRow.nextRow();
|
|
}
|
|
|
|
if (oldIdx != newIdx)
|
|
{
|
|
bpp->relRids[newIdx] = rid;
|
|
// we use a memcpy here instead of copyRow() to avoid expanding the string table;
|
|
memcpy(newRow.getData(), oldRow.getData(), newRow.getSize());
|
|
}
|
|
|
|
oldIdx++;
|
|
oldRow.nextRow();
|
|
newRow.nextRow();
|
|
}
|
|
|
|
rg.setRowCount(outMsg->NVALS); // this gets rid of trailing rows, no need to set them to NULL
|
|
bpp->ridCount = outMsg->NVALS;
|
|
primMsg->NVALS = outMsg->NVALS;
|
|
}
|
|
|
|
void ColumnCommand::projectResultRG(RowGroup& rg, uint32_t pos)
|
|
{
|
|
uint32_t i, offset, gapSize;
|
|
uint8_t* msg8 = (uint8_t*) (outMsg + 1);
|
|
|
|
if (noVB)
|
|
{
|
|
// outMsg has rids in this case
|
|
msg8 += 2;
|
|
gapSize = colType.colWidth + 2;
|
|
}
|
|
else
|
|
gapSize = colType.colWidth;
|
|
|
|
/* TODO: reoptimize these away */
|
|
rg.initRow(&r);
|
|
offset = r.getOffset(pos);
|
|
rowSize = r.getSize();
|
|
|
|
if ((primMsg->NVALS != outMsg->NVALS || outMsg->NVALS != bpp->ridCount) && (!noVB || bpp->sessionID & 0x80000000))
|
|
{
|
|
ostringstream os;
|
|
BRM::DBRM brm;
|
|
BRM::OID_t oid;
|
|
uint16_t dbroot;
|
|
uint32_t partNum;
|
|
uint16_t segNum;
|
|
uint32_t fbo;
|
|
brm.lookupLocal(lbid, 0, false, oid, dbroot, partNum, segNum, fbo);
|
|
|
|
os << __FILE__ << " error on projectResultRG for oid " << oid << " lbid " << lbid;
|
|
|
|
if (primMsg->NVALS != outMsg->NVALS )
|
|
os << ": input rids " << primMsg->NVALS;
|
|
else
|
|
os << ": ridcount " << bpp->ridCount;
|
|
|
|
os << ", output rids " << outMsg->NVALS;
|
|
/*
|
|
BRM::VSSData entry;
|
|
if (bpp->vssCache.find(lbid) != bpp->vssCache.end()) {
|
|
entry = bpp->vssCache[lbid];
|
|
if (entry.returnCode == 0)
|
|
os << " requested version " << entry.verID;
|
|
}
|
|
*/
|
|
os << endl;
|
|
|
|
if (bpp->sessionID & 0x80000000)
|
|
throw NeedToRestartJob(os.str());
|
|
else
|
|
throw PrimitiveColumnProjectResultExcept(os.str());
|
|
}
|
|
else if (primMsg->NVALS != outMsg->NVALS || outMsg->NVALS != bpp->ridCount)
|
|
removeRowsFromRowGroup(rg);
|
|
|
|
idbassert(primMsg->NVALS == outMsg->NVALS);
|
|
idbassert(outMsg->NVALS == bpp->ridCount);
|
|
rg.getRow(0, &r);
|
|
|
|
switch (colType.colWidth)
|
|
{
|
|
case 1:
|
|
{
|
|
for (i = 0; i < outMsg->NVALS; ++i, msg8 += gapSize)
|
|
{
|
|
r.setUintField_offset<1>(*msg8, offset);
|
|
r.nextRow(rowSize);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
for (i = 0; i < outMsg->NVALS; ++i, msg8 += gapSize)
|
|
{
|
|
r.setUintField_offset<2>(*((uint16_t*) msg8), offset);
|
|
r.nextRow(rowSize);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 4:
|
|
{
|
|
for (i = 0; i < outMsg->NVALS; ++i, msg8 += gapSize)
|
|
{
|
|
r.setUintField_offset<4>(*((uint32_t*) msg8), offset);
|
|
r.nextRow(rowSize);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 8:
|
|
{
|
|
for (i = 0; i < outMsg->NVALS; ++i, msg8 += gapSize)
|
|
{
|
|
r.setUintField_offset<8>(*((uint64_t*) msg8), offset);
|
|
r.nextRow(rowSize);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ColumnCommand::project()
|
|
{
|
|
/* bpp->ridCount == 0 would signify a scan operation */
|
|
if (bpp->ridCount == 0)
|
|
{
|
|
*bpp->serialized << (uint32_t) 0;
|
|
blockCount += colType.colWidth;
|
|
return;
|
|
}
|
|
|
|
makeStepMsg();
|
|
issuePrimitive();
|
|
projectResult();
|
|
}
|
|
|
|
void ColumnCommand::projectIntoRowGroup(RowGroup& rg, uint32_t pos)
|
|
{
|
|
if (bpp->ridCount == 0)
|
|
{
|
|
blockCount += colType.colWidth;
|
|
return;
|
|
}
|
|
|
|
makeStepMsg();
|
|
issuePrimitive();
|
|
projectResultRG(rg, pos);
|
|
}
|
|
|
|
void ColumnCommand::nextLBID()
|
|
{
|
|
lbid += colType.colWidth;
|
|
}
|
|
|
|
void ColumnCommand::duplicate(ColumnCommand* cc)
|
|
{
|
|
cc->_isScan = _isScan;
|
|
cc->traceFlags = traceFlags;
|
|
cc->filterString = filterString;
|
|
cc->colType.colDataType = colType.colDataType;
|
|
cc->colType.compressionType = colType.compressionType;
|
|
cc->colType.colWidth = colType.colWidth;
|
|
cc->BOP = BOP;
|
|
cc->filterCount = filterCount;
|
|
cc->fFilterFeeder = fFilterFeeder;
|
|
cc->parsedColumnFilter = parsedColumnFilter;
|
|
cc->suppressFilter = suppressFilter;
|
|
cc->lastLbid = lastLbid;
|
|
cc->r = r;
|
|
cc->rowSize = rowSize;
|
|
cc->Command::duplicate(this);
|
|
}
|
|
|
|
SCommand ColumnCommand::duplicate()
|
|
{
|
|
SCommand ret;
|
|
|
|
ret.reset(new ColumnCommand());
|
|
duplicate((ColumnCommand*) ret.get());
|
|
return ret;
|
|
}
|
|
|
|
bool ColumnCommand::operator==(const ColumnCommand& cc) const
|
|
{
|
|
if (_isScan != cc._isScan)
|
|
return false;
|
|
|
|
if (BOP != cc.BOP)
|
|
return false;
|
|
|
|
if (filterString != cc.filterString)
|
|
return false;
|
|
|
|
if (filterCount != cc.filterCount)
|
|
return false;
|
|
|
|
if (makeAbsRids != cc.makeAbsRids)
|
|
return false;
|
|
|
|
if (colType.colWidth != cc.colType.colWidth)
|
|
return false;
|
|
|
|
if (colType.colDataType != cc.colType.colDataType)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ColumnCommand::operator!=(const ColumnCommand& cc) const
|
|
{
|
|
return !(*this == cc);
|
|
}
|
|
|
|
|
|
ColumnCommand& ColumnCommand::operator=(const ColumnCommand& c)
|
|
{
|
|
_isScan = c._isScan;
|
|
traceFlags = c.traceFlags;
|
|
filterString = c.filterString;
|
|
colType.colDataType = c.colType.colDataType;
|
|
colType.compressionType = c.colType.compressionType;
|
|
colType.colWidth = c.colType.colWidth;
|
|
BOP = c.BOP;
|
|
filterCount = c.filterCount;
|
|
fFilterFeeder = c.fFilterFeeder;
|
|
parsedColumnFilter = c.parsedColumnFilter;
|
|
suppressFilter = c.suppressFilter;
|
|
lastLbid = c.lastLbid;
|
|
return *this;
|
|
}
|
|
|
|
bool ColumnCommand::willPrefetch()
|
|
{
|
|
// if (blockCount > 0)
|
|
// cout << "load rate = " << ((double)loadCount)/((double)blockCount) << endl;
|
|
|
|
// if (!((double)loadCount)/((double)blockCount) > bpp->prefetchThreshold)
|
|
// cout << "suppressing prefetch\n";
|
|
|
|
//return false;
|
|
return (blockCount == 0 || ((double)loadCount) / ((double)blockCount) >
|
|
bpp->prefetchThreshold);
|
|
}
|
|
|
|
void ColumnCommand::disableFilters()
|
|
{
|
|
suppressFilter = true;
|
|
prep(primMsg->OutputType, makeAbsRids);
|
|
}
|
|
|
|
void ColumnCommand::enableFilters()
|
|
{
|
|
suppressFilter = false;
|
|
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 execplan::CalpontSystemCatalog::ColDataType 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::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::getLBIDList(uint32_t loopCount, vector<int64_t>* lbids)
|
|
{
|
|
int64_t firstLBID = lbid, lastLBID = firstLBID + (loopCount * colType.colWidth) - 1, i;
|
|
|
|
for (i = firstLBID; i <= lastLBID; i++)
|
|
lbids->push_back(i);
|
|
}
|
|
|
|
const int64_t ColumnCommand::getLastLbid()
|
|
{
|
|
if (!_isScan)
|
|
return 0;
|
|
|
|
return lastLbid[bpp->dbRoot - 1];
|
|
|
|
#if 0
|
|
/* PL - each dbroot has a different HWM; need to look up the local HWM on start */
|
|
BRM::DBRM dbrm;
|
|
BRM::OID_t oid;
|
|
uint32_t partNum;
|
|
uint16_t segNum;
|
|
uint32_t fbo;
|
|
|
|
dbrm.lookupLocal(primMsg->LBID, bpp->versionNum, false, oid, dbRoot, partNum, segNum, fbo);
|
|
gotDBRoot = true;
|
|
cout << "I think I'm on dbroot " << dbRoot << " lbid=" << primMsg->LBID << " ver=" << bpp->versionNum << endl;
|
|
dbRoot--;
|
|
return lastLbid[dbRoot];
|
|
#endif
|
|
}
|
|
|
|
}
|
|
// vim:ts=4 sw=4:
|
|
|