/**
* Loads only tuple data, not schema, from the serialized tile.
* Used for initial data loading.
* @param allow_export if false, export enabled is overriden for this load.
*/
void Tile::DeserializeTuplesFrom(SerializeInput &input,
type::AbstractPool *pool) {
/*
* Directly receives a Tile buffer.
* [00 01] [02 03] [04 .. 0x]
* rowstart colcount colcount * 1 byte (column types)
*
* [0x+1 .. 0y]
* colcount * strings (column names)
*
* [0y+1 0y+2 0y+3 0y+4]
* rowcount
*
* [0y+5 .. end]
* rowdata
*/
input.ReadInt(); // rowstart
input.ReadByte();
oid_t column_count = input.ReadShort();
PL_ASSERT(column_count > 0);
// Store the following information so that we can provide them to the user on
// failure
type::Type::TypeId types[column_count];
std::vector<std::string> names;
// Skip the column types
for (oid_t column_itr = 0; column_itr < column_count; ++column_itr) {
types[column_itr] = (type::Type::TypeId)input.ReadEnumInSingleByte();
}
// Skip the column names
for (oid_t column_itr = 0; column_itr < column_count; ++column_itr) {
names.push_back(input.ReadTextString());
}
// Check if the column count matches what the temp table is expecting
if (column_count != schema.GetColumnCount()) {
std::stringstream message(std::stringstream::in | std::stringstream::out);
message << "Column count mismatch. Expecting " << schema.GetColumnCount()
<< ", but " << column_count << " given" << std::endl;
message << "Expecting the following columns:" << std::endl;
message << schema.GetColumnCount() << std::endl;
message << "The following columns are given:" << std::endl;
for (oid_t column_itr = 0; column_itr < column_count; column_itr++) {
message << "column " << column_itr << ": " << names[column_itr]
<< ", type = " << types[column_itr] << std::endl;
}
throw SerializationException(message.str());
}
// Use the deserialization routine skipping header
DeserializeTuplesFromWithoutHeader(input, pool);
}
void NValue::deserializeIntoANewNValueList(SerializeInput &input, Pool *dataPool)
{
ValueType elementType = (ValueType)input.readByte();
size_t length = input.readShort();
int trueSize = NValueList::allocationSizeForLength(length);
char* storage = allocateValueStorage(trueSize, dataPool);
::memset(storage, 0, trueSize);
NValueList* nvset = new (storage) NValueList(length, elementType);
nvset->deserializeNValues(input, dataPool);
//TODO: An O(ln(length)) implementation vs. the current O(length) implementation of NValue::inList
// would likely require some kind of sorting/re-org of values at this point post-update pre-lookup.
}
void Table::loadTuplesFromNoHeader(bool allowExport,
SerializeInput &serialize_io,
Pool *stringPool) {
int tupleCount = serialize_io.readInt();
assert(tupleCount >= 0);
// allocate required data blocks first to make them alligned well
while (tupleCount + m_usedTuples > m_allocatedTuples) {
allocateNextBlock();
}
for (int i = 0; i < tupleCount; ++i) {
m_tmpTarget1.move(dataPtrForTuple((int) m_usedTuples + i));
m_tmpTarget1.setDeletedFalse();
m_tmpTarget1.setDirtyFalse();
m_tmpTarget1.setEvictedFalse();
m_tmpTarget1.deserializeFrom(serialize_io, stringPool);
processLoadedTuple( allowExport, m_tmpTarget1);
VOLT_TRACE("Loaded new tuple #%02d\n%s", i, m_tmpTarget1.debug(name()).c_str());
}
populateIndexes(tupleCount);
m_tupleCount += tupleCount;
m_usedTuples += tupleCount;
}
/**
* Loads only tuple data and assumes there is no schema present.
* Used for recovery where the schema is not sent.
* @param allow_export if false, export enabled is overriden for this load.
*/
void Tile::DeserializeTuplesFromWithoutHeader(SerializeInput &input,
type::AbstractPool *pool) {
oid_t tuple_count = input.ReadInt();
PL_ASSERT(tuple_count > 0);
// First, check if we have required space
PL_ASSERT(tuple_count <= num_tuple_slots);
storage::Tuple *temp_tuple = new storage::Tuple(&schema, true);
for (oid_t tuple_itr = 0; tuple_itr < tuple_count; ++tuple_itr) {
temp_tuple->Move(GetTupleLocation(tuple_itr));
temp_tuple->DeserializeFrom(input, pool);
// TRACE("Loaded new tuple #%02d\n%s", tuple_itr,
// temp_target1.debug(Name()).c_str());
}
}
/**
* Therefore a SeqScanPlan is serialized as:
* [(int) total size]
* [(int8_t) plan type]
* [(int) database_id]
* [(int) table_id]
* [(int) num column_id]
* [(int) column id...]
* [(int8_t) expr type] : if invalid, predicate is null
* [(bytes) predicate] : predicate is Expression
* [(int8_t) plan type] : if invalid, parent is null
* [(bytes) parent] : parent is also a plan
*/
bool SeqScanPlan::DeserializeFrom(SerializeInput &input) {
// Read the size of SeqScanPlan class
input.ReadInt();
// Read the type
UNUSED_ATTRIBUTE PlanNodeType plan_type =
(PlanNodeType)input.ReadEnumInSingleByte();
PL_ASSERT(plan_type == GetPlanNodeType());
// Read database id
oid_t database_oid = input.ReadInt();
// Read table id
oid_t table_oid = input.ReadInt();
// Get table and set it to the member
storage::DataTable *target_table = static_cast<storage::DataTable *>(
catalog::Catalog::GetInstance()->GetTableWithOid(database_oid, table_oid));
SetTargetTable(target_table);
// Read the number of column_id and set them to column_ids_
oid_t columnid_count = input.ReadInt();
for (oid_t it = 0; it < columnid_count; it++) {
oid_t column_id = input.ReadInt();
SetColumnId(column_id);
}
// Read the type
ExpressionType expr_type = (ExpressionType)input.ReadEnumInSingleByte();
// Predicate deserialization
if (expr_type != EXPRESSION_TYPE_INVALID) {
switch (expr_type) {
// case EXPRESSION_TYPE_COMPARE_IN:
// predicate_ =
// std::unique_ptr<EXPRESSION_TYPE_COMPARE_IN>(new
// ComparisonExpression (101));
// predicate_.DeserializeFrom(input);
// break;
default: {
LOG_ERROR(
"Expression deserialization :: Unsupported EXPRESSION_TYPE: %u ",
expr_type);
break;
}
}
}
// Read the type of parent
PlanNodeType parent_type = (PlanNodeType)input.ReadEnumInSingleByte();
// Parent deserialization
if (parent_type != PLAN_NODE_TYPE_INVALID) {
switch (expr_type) {
// case EXPRESSION_TYPE_COMPARE_IN:
// predicate_ =
// std::unique_ptr<EXPRESSION_TYPE_COMPARE_IN>(new
// ComparisonExpression (101));
// predicate_.DeserializeFrom(input);
// break;
default: {
LOG_ERROR("Parent deserialization :: Unsupported PlanNodeType: %u ",
expr_type);
break;
}
}
}
return true;
}
void Table::loadTuplesFrom(bool allowELT,
SerializeInput &serialize_io,
Pool *stringPool) {
/*
* directly receives a VoltTable buffer.
* [00 01] [02 03] [04 .. 0x]
* headersize colcount colcount * 1 byte (column types)
*
* [0x+1 .. 0y]
* colcount * strings (column names)
*
* [0y+1 0y+2 0y+3 0y+4]
* rowcount
*
* [0y+5 .. end]
* rowdata
*/
// todo: just skip ahead to this position
serialize_io.readInt(); // rowstart
serialize_io.readByte(); // status
int16_t colcount = serialize_io.readShort();
assert(colcount >= 0);
// Store the following information so that we can provide them to the user
// on failure
ValueType types[colcount];
std::string names[colcount];
// skip the column types
for (int i = 0; i < colcount; ++i) {
types[i] = (ValueType) serialize_io.readEnumInSingleByte();
}
// skip the column names
for (int i = 0; i < colcount; ++i) {
names[i] = serialize_io.readTextString();
}
// Check if the column count matches what the temp table is expecting
if (colcount != m_schema->columnCount()) {
std::stringstream message(std::stringstream::in
| std::stringstream::out);
message << "Column count mismatch. Expecting "
<< m_schema->columnCount()
<< ", but " << colcount << " given" << std::endl;
message << "Expecting the following columns:" << std::endl;
message << debug() << std::endl;
message << "The following columns are given:" << std::endl;
for (int i = 0; i < colcount; i++) {
message << "column " << i << ": " << names[i]
<< ", type = " << getTypeName(types[i]) << std::endl;
}
throw SerializableEEException(VOLT_EE_EXCEPTION_TYPE_EEEXCEPTION,
message.str().c_str());
}
int tupleCount = serialize_io.readInt();
assert(tupleCount >= 0);
// allocate required data blocks first to make them alligned well
while (tupleCount + m_usedTuples > m_allocatedTuples) {
allocateNextBlock();
}
for (int i = 0; i < tupleCount; ++i) {
m_tmpTarget1.move(dataPtrForTuple((int) m_usedTuples + i));
m_tmpTarget1.setDeletedFalse();
m_tmpTarget1.setDirtyFalse();
m_tmpTarget1.deserializeFrom(serialize_io, stringPool);
processLoadedTuple( allowELT, m_tmpTarget1);
}
populateIndexes(tupleCount);
m_tupleCount += tupleCount;
m_usedTuples += tupleCount;
}
void Table::loadTuplesFrom(bool allowExport,
SerializeInput &serialize_io,
Pool *stringPool) {
/*
* directly receives a VoltTable buffer.
* [00 01] [02 03] [04 .. 0x]
* rowstart colcount colcount * 1 byte (column types)
*
* [0x+1 .. 0y]
* colcount * strings (column names)
*
* [0y+1 0y+2 0y+3 0y+4]
* rowcount
*
* [0y+5 .. end]
* rowdata
*/
// todo: just skip ahead to this position
serialize_io.readInt(); // rowstart
serialize_io.readByte();
int16_t colcount = serialize_io.readShort();
assert(colcount >= 0);
// Store the following information so that we can provide them to the user
// on failure
ValueType types[colcount];
std::string names[colcount];
// skip the column types
for (int i = 0; i < colcount; ++i) {
types[i] = (ValueType) serialize_io.readEnumInSingleByte();
}
// skip the column names
for (int i = 0; i < colcount; ++i) {
names[i] = serialize_io.readTextString();
}
// Check if the column count matches what the temp table is expecting
if (colcount != m_schema->columnCount()) {
std::stringstream message(std::stringstream::in
| std::stringstream::out);
message << "Column count mismatch. Expecting "
<< m_schema->columnCount()
<< ", but " << colcount << " given" << std::endl;
message << "Expecting the following columns:" << std::endl;
message << debug() << std::endl;
message << "The following columns are given:" << std::endl;
for (int i = 0; i < colcount; i++) {
message << "column " << i << ": " << names[i]
<< ", type = " << getTypeName(types[i]) << std::endl;
}
throw SerializableEEException(VOLT_EE_EXCEPTION_TYPE_EEEXCEPTION,
message.str().c_str());
}
loadTuplesFromNoHeader( allowExport, serialize_io, stringPool);
}
