mariadb-columnstore-engine/primitives/primproc/passthrucommand.cpp

/* 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: passthrucommand.cpp 2093 2013-05-08 19:23:58Z pleblanc $
// C++ Implementation: passthrucommand
//
// Description:
//
//
// Author: Patrick <pleblanc@localhost.localdomain>, (C) 2008
//
// Copyright: See COPYING file that comes with this distribution
//
//

#include <unistd.h>

#include "bpp.h"

using namespace std;
using namespace messageqcpp;
using namespace rowgroup;

namespace primitiveprocessor
{

PassThruCommand::PassThruCommand() : Command(PASS_THRU)
{
}

PassThruCommand::~PassThruCommand()
{
}

void PassThruCommand::prep(int8_t outputType, bool makeAbsRids)
{
	if (bpp->ot == ROW_GROUP) {
		bpp->outputRG.initRow(&r);
		rowSize = r.getSize();
	}
}

void PassThruCommand::execute()
{
// 	throw logic_error("PassThruCommand isn't a filter step");
}

void PassThruCommand::project()
{
	uint32_t i;

	*bpp->serialized << (uint32_t) (bpp->ridCount * colWidth);
#if 0
 	cout << "pass thru serializing " << (uint32_t) (bpp->ridCount * colWidth) << " bytes:\n";
 	cout << "at relative position " << bpp->serialized->length() - sizeof(ISMPacketHeader) - sizeof(PrimitiveHeader) - 4 << endl;
 	for (i = 0; i < bpp->ridCount; i++)
 		cout << "   " << i << ": " << bpp->values[i] << endl;
#endif
	switch (colWidth) {
		case 8:
			bpp->serialized->append((uint8_t *) bpp->values, bpp->ridCount << 3);
			break;
		case 4:
			for (i = 0; i < bpp->ridCount; i++)
				*bpp->serialized << (uint32_t) bpp->values[i];
			break;
		case 2:
			for (i = 0; i < bpp->ridCount; i++)
				*bpp->serialized << (uint16_t) bpp->values[i];
			break;
		case 1:
			for (i = 0; i < bpp->ridCount; i++)
				*bpp->serialized << (uint8_t) bpp->values[i];
			break;
		default:
			throw logic_error("PassThruCommand has a bad column width");
	}
}

void PassThruCommand::projectIntoRowGroup(RowGroup &rg, uint32_t col)
{
	uint32_t i;

	rg.initRow(&r);
	rg.getRow(0, &r);
	uint32_t offset = r.getOffset(col);
	rowSize = r.getSize();

	switch (colWidth) {
		case 1:
			for (i = 0; i < bpp->ridCount; i++) {
//				cout << "PTC: " << bpp->values[i] << endl;
				r.setUintField_offset<1>(bpp->values[i], offset);
				r.nextRow(rowSize);
			}
			break;
		case 2:
			for (i = 0; i < bpp->ridCount; i++) {
//				cout << "PTC: " << bpp->values[i] << endl;
				r.setUintField_offset<2>(bpp->values[i], offset);
				r.nextRow(rowSize);
			}
			break;
		case 4:
			for (i = 0; i < bpp->ridCount; i++) {
				r.setUintField_offset<4>(bpp->values[i], offset);
				r.nextRow(rowSize);
			}
			break;
		case 8:
			for (i = 0; i < bpp->ridCount; i++) {
// 				cout << "PTC: " << bpp->values[i] << endl;
				r.setUintField_offset<8>(bpp->values[i], offset);
				r.nextRow(rowSize);
			}
			break;
	}
}

uint64_t PassThruCommand::getLBID()
{
	return 0;
}

void PassThruCommand::nextLBID()
{
}

void PassThruCommand::createCommand(ByteStream &bs)
{
    bs.advance(1);
	bs >> colWidth;
	Command::createCommand(bs);
}

void PassThruCommand::resetCommand(ByteStream &bs)
{
}

SCommand PassThruCommand::duplicate()
{
	SCommand ret;
	PassThruCommand *p;

	ret.reset(new PassThruCommand());
	p = (PassThruCommand *) ret.get();
	p->colWidth = colWidth;
	p->Command::duplicate(this);
	return ret;
}

bool PassThruCommand::operator==(const PassThruCommand &p) const
{
	if (colWidth != p.colWidth)
		return false;
	return true;
}

bool PassThruCommand::operator!=(const PassThruCommand &p) const
{
	return !(*this == p);
}

};