TEST_F(SerializeIOTest, ReadWrite) {
CopySerializeOutput out;
writeTestSuite(&out);
ReferenceSerializeInput in(out.data(), out.size());
readTestSuite(&in);
CopySerializeInput in2(out.data(), out.size());
memset(const_cast<char*>(out.data()), 0, out.size());
readTestSuite(&in2);
}
/**
* @brief Serialize given data
* @return true if we serialize data otherwise false
*/
bool TupleRecord::Serialize(CopySerializeOutput &output) {
bool status = true;
output.Reset();
// Serialize the common variables such as database oid, table oid, etc.
SerializeHeader(output);
// Serialize other parts depends on type
switch (GetType()) {
case LOGRECORD_TYPE_ARIES_TUPLE_INSERT:
case LOGRECORD_TYPE_ARIES_TUPLE_UPDATE: {
storage::Tuple *tuple = (storage::Tuple *)data;
tuple->SerializeTo(output);
break;
}
case LOGRECORD_TYPE_ARIES_TUPLE_DELETE:
// Nothing to do here !
break;
case LOGRECORD_TYPE_PELOTON_TUPLE_INSERT:
case LOGRECORD_TYPE_PELOTON_TUPLE_DELETE:
case LOGRECORD_TYPE_PELOTON_TUPLE_UPDATE:
// Nothing to do here !
break;
default: {
LOG_WARN("Unsupported TUPLE RECORD TYPE\n");
status = false;
break;
}
}
message_length = output.Size();
message = new char[message_length];
std::memcpy(message, output.Data(), message_length);
return status;
}
TEST(SerializeOutput, ReserveBytes) {
CopySerializeOutput out;
size_t offset = out.reserveBytes(4);
EXPECT_EQ(0, offset);
EXPECT_EQ(4, out.size());
static const uint32_t DATA = 0x01020304;
// Writing past the end = bad
EXPECT_DEATH(out.writeBytesAt(1, &DATA, sizeof(DATA)));
size_t offset2 = out.reserveBytes(5);
EXPECT_EQ(4, offset2);
EXPECT_EQ(9, out.size());
size_t nextOffset = out.writeBytesAt(1, &DATA, sizeof(DATA));
EXPECT_EQ(1+sizeof(DATA), nextOffset);
EXPECT_EQ(0, memcmp(static_cast<const char*>(out.data()) + 1, &DATA, sizeof(DATA)));
}
/**
* @brief Serialize given data
* @return true if we serialize data otherwise false
*/
bool TransactionRecord::Serialize(CopySerializeOutput &output) {
bool status = true;
output.Reset();
// First, write out the log record type
output.WriteEnumInSingleByte(log_record_type);
// Then reserve 4 bytes for the header size to be written later
size_t start = output.Position();
output.WriteInt(0);
output.WriteLong(cid);
// Write out the header now
int32_t header_length =
static_cast<int32_t>(output.Position() - start - sizeof(int32_t));
output.WriteIntAt(start, header_length);
message_length = output.Size();
message = new char[message_length];
PL_MEMCPY(message, output.Data(), message_length);
return status;
}
/**
* @brief Serialize LogRecordHeader
* @param output
*/
void TupleRecord::SerializeHeader(CopySerializeOutput &output) {
// Record LogRecordType first
output.WriteEnumInSingleByte(log_record_type);
size_t start = output.Position();
// then reserve 4 bytes for the header size
output.WriteInt(0);
output.WriteLong(db_oid);
output.WriteLong(table_oid);
output.WriteLong(txn_id);
output.WriteLong(insert_location.block);
output.WriteLong(insert_location.offset);
output.WriteLong(delete_location.block);
output.WriteLong(delete_location.offset);
output.WriteIntAt(
start, static_cast<int32_t>(output.Position() - start - sizeof(int32_t)));
}
