void Table::loadTuplesFromNoHeader(SerializeInputBE &serialize_io,
Pool *stringPool,
ReferenceSerializeOutput *uniqueViolationOutput,
bool shouldDRStreamRow) {
int tupleCount = serialize_io.readInt();
assert(tupleCount >= 0);
TableTuple target(m_schema);
//Reserve space for a length prefix for rows that violate unique constraints
//If there is no output supplied it will just throw
size_t lengthPosition = 0;
int32_t serializedTupleCount = 0;
size_t tupleCountPosition = 0;
if (uniqueViolationOutput != NULL) {
lengthPosition = uniqueViolationOutput->reserveBytes(4);
}
for (int i = 0; i < tupleCount; ++i) {
nextFreeTuple(&target);
target.setActiveTrue();
target.setDirtyFalse();
target.setPendingDeleteFalse();
target.setPendingDeleteOnUndoReleaseFalse();
target.deserializeFrom(serialize_io, stringPool);
processLoadedTuple(target, uniqueViolationOutput, serializedTupleCount, tupleCountPosition, shouldDRStreamRow);
}
//If unique constraints are being handled, write the length/size of constraints that occured
if (uniqueViolationOutput != NULL) {
if (serializedTupleCount == 0) {
uniqueViolationOutput->writeIntAt(lengthPosition, 0);
} else {
uniqueViolationOutput->writeIntAt(lengthPosition,
static_cast<int32_t>(uniqueViolationOutput->position() - lengthPosition - sizeof(int32_t)));
uniqueViolationOutput->writeIntAt(tupleCountPosition,
serializedTupleCount);
}
}
}
void Tuple::DeserializeWithHeaderFrom(SerializeInputBE &input) {
PL_ASSERT(tuple_schema);
PL_ASSERT(tuple_data);
input.ReadInt(); // Read in the tuple size, discard
const int column_count = tuple_schema->GetColumnCount();
for (int column_itr = 0; column_itr < column_count; column_itr++) {
const ValueType type = tuple_schema->GetType(column_itr);
const bool is_inlined = tuple_schema->IsInlined(column_itr);
char *data_ptr = GetDataPtr(column_itr);
const int32_t column_length = tuple_schema->GetLength(column_itr);
// TODO: Not sure about arguments
const bool is_in_bytes = false;
Value::DeserializeFrom(input, NULL, data_ptr, type, is_inlined,
column_length, is_in_bytes);
}
}
void Tuple::DeserializeFrom(SerializeInputBE &input, VarlenPool *dataPool) {
PL_ASSERT(tuple_schema);
PL_ASSERT(tuple_data);
input.ReadInt();
const int column_count = tuple_schema->GetColumnCount();
for (int column_itr = 0; column_itr < column_count; column_itr++) {
const ValueType type = tuple_schema->GetType(column_itr);
/**
* DeserializeFrom is only called when we serialize/deserialize tables.
* The serialization format for Strings/Objects in a serialized table
* happens to have the same in memory representation as the Strings/Objects
* in a Tuple. The goal here is to wrap the serialized representation of
* the value in an Value and then serialize that into the tuple from the
* Value. This makes it possible to push more value specific functionality
* out of Tuple. The memory allocation will be performed when serializing
* to tuple storage.
*/
const bool is_inlined = tuple_schema->IsInlined(column_itr);
int32_t column_length;
char *data_ptr = GetDataPtr(column_itr);
if (is_inlined) {
column_length = tuple_schema->GetLength(column_itr);
} else {
column_length = tuple_schema->GetVariableLength(column_itr);
}
// TODO: Not sure about arguments
const bool is_in_bytes = false;
Value::DeserializeFrom(input, dataPool, data_ptr, type, is_inlined,
column_length, is_in_bytes);
}
}
void Table::loadTuplesFrom(SerializeInputBE &serialInput,
Pool *stringPool,
ReferenceSerializeOutput *uniqueViolationOutput,
bool shouldDRStreamRow) {
/*
* 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
serialInput.readInt(); // rowstart
serialInput.readByte();
int16_t colcount = serialInput.readShort();
assert(colcount >= 0);
// Store the following information so that we can provide them to the user
// on failure
ValueType types[colcount];
boost::scoped_array<std::string> names(new std::string[colcount]);
// skip the column types
for (int i = 0; i < colcount; ++i) {
types[i] = (ValueType) serialInput.readEnumInSingleByte();
}
// skip the column names
for (int i = 0; i < colcount; ++i) {
names[i] = serialInput.readTextString();
}
// Check if the column count matches what the temp table is expecting
int16_t expectedColumnCount = static_cast<int16_t>(m_schema->columnCount() + m_schema->hiddenColumnCount());
if (colcount != expectedColumnCount) {
std::stringstream message(std::stringstream::in
| std::stringstream::out);
message << "Column count mismatch. Expecting "
<< expectedColumnCount
<< ", 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(serialInput, stringPool, uniqueViolationOutput, shouldDRStreamRow);
}