duckdb 0.8.2-dev4142.0 → 0.8.2-dev4203.0

package/src/duckdb/src/storage/serialization/serialize_storage.cpp

@@ -3,20 +3,55 @@
 // Do not edit this file manually, your changes will be overwritten
 //===----------------------------------------------------------------------===//
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/storage/block.hpp"
+#include "duckdb/storage/data_pointer.hpp"
 #include "duckdb/storage/statistics/distinct_statistics.hpp"
 
 namespace duckdb {
 
-void DistinctStatistics::FormatSerialize(FormatSerializer &serializer) const {
+void BlockPointer::Serialize(Serializer &serializer) const {
+	serializer.WriteProperty(100, "block_id", block_id);
+	serializer.WriteProperty(101, "offset", offset);
+}
+
+BlockPointer BlockPointer::Deserialize(Deserializer &deserializer) {
+	auto block_id = deserializer.ReadProperty<block_id_t>(100, "block_id");
+	auto offset = deserializer.ReadProperty<uint32_t>(101, "offset");
+	BlockPointer result(block_id, offset);
+	return result;
+}
+
+void DataPointer::Serialize(Serializer &serializer) const {
+	serializer.WriteProperty(100, "row_start", row_start);
+	serializer.WriteProperty(101, "tuple_count", tuple_count);
+	serializer.WriteProperty(102, "block_pointer", block_pointer);
+	serializer.WriteProperty(103, "compression_type", compression_type);
+	serializer.WriteProperty(104, "statistics", statistics);
+}
+
+DataPointer DataPointer::Deserialize(Deserializer &deserializer) {
+	auto row_start = deserializer.ReadProperty<uint64_t>(100, "row_start");
+	auto tuple_count = deserializer.ReadProperty<uint64_t>(101, "tuple_count");
+	auto block_pointer = deserializer.ReadProperty<BlockPointer>(102, "block_pointer");
+	auto compression_type = deserializer.ReadProperty<CompressionType>(103, "compression_type");
+	auto statistics = deserializer.ReadProperty<BaseStatistics>(104, "statistics");
+	DataPointer result(std::move(statistics));
+	result.row_start = row_start;
+	result.tuple_count = tuple_count;
+	result.block_pointer = block_pointer;
+	result.compression_type = compression_type;
+	return result;
+}
+
+void DistinctStatistics::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "sample_count", sample_count);
 	serializer.WriteProperty(101, "total_count", total_count);
 	serializer.WriteProperty(102, "log", log);
 }
 
-unique_ptr<DistinctStatistics> DistinctStatistics::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<DistinctStatistics> DistinctStatistics::Deserialize(Deserializer &deserializer) {
 	auto sample_count = deserializer.ReadProperty<idx_t>(100, "sample_count");
 	auto total_count = deserializer.ReadProperty<idx_t>(101, "total_count");
 	auto log = deserializer.ReadProperty<unique_ptr<HyperLogLog>>(102, "log");
@@ -24,12 +59,12 @@ unique_ptr<DistinctStatistics> DistinctStatistics::FormatDeserialize(FormatDeser
 	return result;
 }
 
-void MetaBlockPointer::FormatSerialize(FormatSerializer &serializer) const {
+void MetaBlockPointer::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "block_pointer", block_pointer);
 	serializer.WriteProperty(101, "offset", offset);
 }
 
-MetaBlockPointer MetaBlockPointer::FormatDeserialize(FormatDeserializer &deserializer) {
+MetaBlockPointer MetaBlockPointer::Deserialize(Deserializer &deserializer) {
 	auto block_pointer = deserializer.ReadProperty<idx_t>(100, "block_pointer");
 	auto offset = deserializer.ReadProperty<uint32_t>(101, "offset");
 	MetaBlockPointer result(block_pointer, offset);

package/src/duckdb/src/storage/serialization/serialize_table_filter.cpp

@@ -3,8 +3,8 @@
 // Do not edit this file manually, your changes will be overwritten
 //===----------------------------------------------------------------------===//
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/planner/filter/null_filter.hpp"
 #include "duckdb/planner/filter/constant_filter.hpp"
@@ -12,28 +12,28 @@
 
 namespace duckdb {
 
-void TableFilter::FormatSerialize(FormatSerializer &serializer) const {
+void TableFilter::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "filter_type", filter_type);
 }
 
-unique_ptr<TableFilter> TableFilter::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableFilter> TableFilter::Deserialize(Deserializer &deserializer) {
 	auto filter_type = deserializer.ReadProperty<TableFilterType>(100, "filter_type");
 	unique_ptr<TableFilter> result;
 	switch (filter_type) {
 	case TableFilterType::CONJUNCTION_AND:
-		result = ConjunctionAndFilter::FormatDeserialize(deserializer);
+		result = ConjunctionAndFilter::Deserialize(deserializer);
 		break;
 	case TableFilterType::CONJUNCTION_OR:
-		result = ConjunctionOrFilter::FormatDeserialize(deserializer);
+		result = ConjunctionOrFilter::Deserialize(deserializer);
 		break;
 	case TableFilterType::CONSTANT_COMPARISON:
-		result = ConstantFilter::FormatDeserialize(deserializer);
+		result = ConstantFilter::Deserialize(deserializer);
 		break;
 	case TableFilterType::IS_NOT_NULL:
-		result = IsNotNullFilter::FormatDeserialize(deserializer);
+		result = IsNotNullFilter::Deserialize(deserializer);
 		break;
 	case TableFilterType::IS_NULL:
-		result = IsNullFilter::FormatDeserialize(deserializer);
+		result = IsNullFilter::Deserialize(deserializer);
 		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of TableFilter!");
@@ -41,55 +41,55 @@ unique_ptr<TableFilter> TableFilter::FormatDeserialize(FormatDeserializer &deser
 	return result;
 }
 
-void ConjunctionAndFilter::FormatSerialize(FormatSerializer &serializer) const {
-	TableFilter::FormatSerialize(serializer);
+void ConjunctionAndFilter::Serialize(Serializer &serializer) const {
+	TableFilter::Serialize(serializer);
 	serializer.WriteProperty(200, "child_filters", child_filters);
 }
 
-unique_ptr<TableFilter> ConjunctionAndFilter::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableFilter> ConjunctionAndFilter::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ConjunctionAndFilter>(new ConjunctionAndFilter());
 	deserializer.ReadProperty(200, "child_filters", result->child_filters);
 	return std::move(result);
 }
 
-void ConjunctionOrFilter::FormatSerialize(FormatSerializer &serializer) const {
-	TableFilter::FormatSerialize(serializer);
+void ConjunctionOrFilter::Serialize(Serializer &serializer) const {
+	TableFilter::Serialize(serializer);
 	serializer.WriteProperty(200, "child_filters", child_filters);
 }
 
-unique_ptr<TableFilter> ConjunctionOrFilter::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableFilter> ConjunctionOrFilter::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ConjunctionOrFilter>(new ConjunctionOrFilter());
 	deserializer.ReadProperty(200, "child_filters", result->child_filters);
 	return std::move(result);
 }
 
-void ConstantFilter::FormatSerialize(FormatSerializer &serializer) const {
-	TableFilter::FormatSerialize(serializer);
+void ConstantFilter::Serialize(Serializer &serializer) const {
+	TableFilter::Serialize(serializer);
 	serializer.WriteProperty(200, "comparison_type", comparison_type);
 	serializer.WriteProperty(201, "constant", constant);
 }
 
-unique_ptr<TableFilter> ConstantFilter::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableFilter> ConstantFilter::Deserialize(Deserializer &deserializer) {
 	auto comparison_type = deserializer.ReadProperty<ExpressionType>(200, "comparison_type");
 	auto constant = deserializer.ReadProperty<Value>(201, "constant");
 	auto result = duckdb::unique_ptr<ConstantFilter>(new ConstantFilter(comparison_type, constant));
 	return std::move(result);
 }
 
-void IsNotNullFilter::FormatSerialize(FormatSerializer &serializer) const {
-	TableFilter::FormatSerialize(serializer);
+void IsNotNullFilter::Serialize(Serializer &serializer) const {
+	TableFilter::Serialize(serializer);
 }
 
-unique_ptr<TableFilter> IsNotNullFilter::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableFilter> IsNotNullFilter::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<IsNotNullFilter>(new IsNotNullFilter());
 	return std::move(result);
 }
 
-void IsNullFilter::FormatSerialize(FormatSerializer &serializer) const {
-	TableFilter::FormatSerialize(serializer);
+void IsNullFilter::Serialize(Serializer &serializer) const {
+	TableFilter::Serialize(serializer);
 }
 
-unique_ptr<TableFilter> IsNullFilter::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableFilter> IsNullFilter::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<IsNullFilter>(new IsNullFilter());
 	return std::move(result);
 }

package/src/duckdb/src/storage/serialization/serialize_tableref.cpp

@@ -3,44 +3,44 @@
 // Do not edit this file manually, your changes will be overwritten
 //===----------------------------------------------------------------------===//
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/parser/tableref/list.hpp"
 
 namespace duckdb {
 
-void TableRef::FormatSerialize(FormatSerializer &serializer) const {
+void TableRef::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "type", type);
 	serializer.WriteProperty(101, "alias", alias);
 	serializer.WritePropertyWithDefault(102, "sample", sample, unique_ptr<SampleOptions>());
 }
 
-unique_ptr<TableRef> TableRef::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableRef> TableRef::Deserialize(Deserializer &deserializer) {
 	auto type = deserializer.ReadProperty<TableReferenceType>(100, "type");
 	auto alias = deserializer.ReadProperty<string>(101, "alias");
 	auto sample = deserializer.ReadPropertyWithDefault<unique_ptr<SampleOptions>>(102, "sample", unique_ptr<SampleOptions>());
 	unique_ptr<TableRef> result;
 	switch (type) {
 	case TableReferenceType::BASE_TABLE:
-		result = BaseTableRef::FormatDeserialize(deserializer);
+		result = BaseTableRef::Deserialize(deserializer);
 		break;
 	case TableReferenceType::EMPTY:
-		result = EmptyTableRef::FormatDeserialize(deserializer);
+		result = EmptyTableRef::Deserialize(deserializer);
 		break;
 	case TableReferenceType::EXPRESSION_LIST:
-		result = ExpressionListRef::FormatDeserialize(deserializer);
+		result = ExpressionListRef::Deserialize(deserializer);
 		break;
 	case TableReferenceType::JOIN:
-		result = JoinRef::FormatDeserialize(deserializer);
+		result = JoinRef::Deserialize(deserializer);
 		break;
 	case TableReferenceType::PIVOT:
-		result = PivotRef::FormatDeserialize(deserializer);
+		result = PivotRef::Deserialize(deserializer);
 		break;
 	case TableReferenceType::SUBQUERY:
-		result = SubqueryRef::FormatDeserialize(deserializer);
+		result = SubqueryRef::Deserialize(deserializer);
 		break;
 	case TableReferenceType::TABLE_FUNCTION:
-		result = TableFunctionRef::FormatDeserialize(deserializer);
+		result = TableFunctionRef::Deserialize(deserializer);
 		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of TableRef!");
@@ -50,15 +50,15 @@ unique_ptr<TableRef> TableRef::FormatDeserialize(FormatDeserializer &deserialize
 	return result;
 }
 
-void BaseTableRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
+void BaseTableRef::Serialize(Serializer &serializer) const {
+	TableRef::Serialize(serializer);
 	serializer.WriteProperty(200, "schema_name", schema_name);
 	serializer.WriteProperty(201, "table_name", table_name);
 	serializer.WriteProperty(202, "column_name_alias", column_name_alias);
 	serializer.WriteProperty(203, "catalog_name", catalog_name);
 }
 
-unique_ptr<TableRef> BaseTableRef::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableRef> BaseTableRef::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<BaseTableRef>(new BaseTableRef());
 	deserializer.ReadProperty(200, "schema_name", result->schema_name);
 	deserializer.ReadProperty(201, "table_name", result->table_name);
@@ -67,23 +67,23 @@ unique_ptr<TableRef> BaseTableRef::FormatDeserialize(FormatDeserializer &deseria
 	return std::move(result);
 }
 
-void EmptyTableRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
+void EmptyTableRef::Serialize(Serializer &serializer) const {
+	TableRef::Serialize(serializer);
 }
 
-unique_ptr<TableRef> EmptyTableRef::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableRef> EmptyTableRef::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<EmptyTableRef>(new EmptyTableRef());
 	return std::move(result);
 }
 
-void ExpressionListRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
+void ExpressionListRef::Serialize(Serializer &serializer) const {
+	TableRef::Serialize(serializer);
 	serializer.WriteProperty(200, "expected_names", expected_names);
 	serializer.WriteProperty(201, "expected_types", expected_types);
 	serializer.WriteProperty(202, "values", values);
 }
 
-unique_ptr<TableRef> ExpressionListRef::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableRef> ExpressionListRef::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ExpressionListRef>(new ExpressionListRef());
 	deserializer.ReadProperty(200, "expected_names", result->expected_names);
 	deserializer.ReadProperty(201, "expected_types", result->expected_types);
@@ -91,8 +91,8 @@ unique_ptr<TableRef> ExpressionListRef::FormatDeserialize(FormatDeserializer &de
 	return std::move(result);
 }
 
-void JoinRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
+void JoinRef::Serialize(Serializer &serializer) const {
+	TableRef::Serialize(serializer);
 	serializer.WriteProperty(200, "left", left);
 	serializer.WriteProperty(201, "right", right);
 	serializer.WritePropertyWithDefault(202, "condition", condition, unique_ptr<ParsedExpression>());
@@ -101,7 +101,7 @@ void JoinRef::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(205, "using_columns", using_columns);
 }
 
-unique_ptr<TableRef> JoinRef::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableRef> JoinRef::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<JoinRef>(new JoinRef());
 	deserializer.ReadProperty(200, "left", result->left);
 	deserializer.ReadProperty(201, "right", result->right);
@@ -112,8 +112,8 @@ unique_ptr<TableRef> JoinRef::FormatDeserialize(FormatDeserializer &deserializer
 	return std::move(result);
 }
 
-void PivotRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
+void PivotRef::Serialize(Serializer &serializer) const {
+	TableRef::Serialize(serializer);
 	serializer.WriteProperty(200, "source", source);
 	serializer.WriteProperty(201, "aggregates", aggregates);
 	serializer.WriteProperty(202, "unpivot_names", unpivot_names);
@@ -123,7 +123,7 @@ void PivotRef::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(206, "include_nulls", include_nulls);
 }
 
-unique_ptr<TableRef> PivotRef::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableRef> PivotRef::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<PivotRef>(new PivotRef());
 	deserializer.ReadProperty(200, "source", result->source);
 	deserializer.ReadProperty(201, "aggregates", result->aggregates);
@@ -135,26 +135,26 @@ unique_ptr<TableRef> PivotRef::FormatDeserialize(FormatDeserializer &deserialize
 	return std::move(result);
 }
 
-void SubqueryRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
+void SubqueryRef::Serialize(Serializer &serializer) const {
+	TableRef::Serialize(serializer);
 	serializer.WriteProperty(200, "subquery", subquery);
 	serializer.WriteProperty(201, "column_name_alias", column_name_alias);
 }
 
-unique_ptr<TableRef> SubqueryRef::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableRef> SubqueryRef::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<SubqueryRef>(new SubqueryRef());
 	deserializer.ReadProperty(200, "subquery", result->subquery);
 	deserializer.ReadProperty(201, "column_name_alias", result->column_name_alias);
 	return std::move(result);
 }
 
-void TableFunctionRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
+void TableFunctionRef::Serialize(Serializer &serializer) const {
+	TableRef::Serialize(serializer);
 	serializer.WriteProperty(200, "function", function);
 	serializer.WriteProperty(201, "column_name_alias", column_name_alias);
 }
 
-unique_ptr<TableRef> TableFunctionRef::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<TableRef> TableFunctionRef::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<TableFunctionRef>(new TableFunctionRef());
 	deserializer.ReadProperty(200, "function", result->function);
 	deserializer.ReadProperty(201, "column_name_alias", result->column_name_alias);

package/src/duckdb/src/storage/serialization/serialize_types.cpp

@@ -3,30 +3,30 @@
 // Do not edit this file manually, your changes will be overwritten
 //===----------------------------------------------------------------------===//
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/common/extra_type_info.hpp"
 
 namespace duckdb {
 
-void ExtraTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
+void ExtraTypeInfo::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "type", type);
 	serializer.WriteProperty(101, "alias", alias);
 }
 
-shared_ptr<ExtraTypeInfo> ExtraTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+shared_ptr<ExtraTypeInfo> ExtraTypeInfo::Deserialize(Deserializer &deserializer) {
 	auto type = deserializer.ReadProperty<ExtraTypeInfoType>(100, "type");
 	auto alias = deserializer.ReadProperty<string>(101, "alias");
 	shared_ptr<ExtraTypeInfo> result;
 	switch (type) {
 	case ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO:
-		result = AggregateStateTypeInfo::FormatDeserialize(deserializer);
+		result = AggregateStateTypeInfo::Deserialize(deserializer);
 		break;
 	case ExtraTypeInfoType::DECIMAL_TYPE_INFO:
-		result = DecimalTypeInfo::FormatDeserialize(deserializer);
+		result = DecimalTypeInfo::Deserialize(deserializer);
 		break;
 	case ExtraTypeInfoType::ENUM_TYPE_INFO:
-		result = EnumTypeInfo::FormatDeserialize(deserializer);
+		result = EnumTypeInfo::Deserialize(deserializer);
 		break;
 	case ExtraTypeInfoType::GENERIC_TYPE_INFO:
 		result = make_shared<ExtraTypeInfo>(type);
@@ -34,16 +34,16 @@ shared_ptr<ExtraTypeInfo> ExtraTypeInfo::FormatDeserialize(FormatDeserializer &d
 	case ExtraTypeInfoType::INVALID_TYPE_INFO:
 		return nullptr;
 	case ExtraTypeInfoType::LIST_TYPE_INFO:
-		result = ListTypeInfo::FormatDeserialize(deserializer);
+		result = ListTypeInfo::Deserialize(deserializer);
 		break;
 	case ExtraTypeInfoType::STRING_TYPE_INFO:
-		result = StringTypeInfo::FormatDeserialize(deserializer);
+		result = StringTypeInfo::Deserialize(deserializer);
 		break;
 	case ExtraTypeInfoType::STRUCT_TYPE_INFO:
-		result = StructTypeInfo::FormatDeserialize(deserializer);
+		result = StructTypeInfo::Deserialize(deserializer);
 		break;
 	case ExtraTypeInfoType::USER_TYPE_INFO:
-		result = UserTypeInfo::FormatDeserialize(deserializer);
+		result = UserTypeInfo::Deserialize(deserializer);
 		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of ExtraTypeInfo!");
@@ -52,14 +52,14 @@ shared_ptr<ExtraTypeInfo> ExtraTypeInfo::FormatDeserialize(FormatDeserializer &d
 	return result;
 }
 
-void AggregateStateTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ExtraTypeInfo::FormatSerialize(serializer);
+void AggregateStateTypeInfo::Serialize(Serializer &serializer) const {
+	ExtraTypeInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "function_name", state_type.function_name);
 	serializer.WriteProperty(201, "return_type", state_type.return_type);
 	serializer.WriteProperty(202, "bound_argument_types", state_type.bound_argument_types);
 }
 
-shared_ptr<ExtraTypeInfo> AggregateStateTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+shared_ptr<ExtraTypeInfo> AggregateStateTypeInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::shared_ptr<AggregateStateTypeInfo>(new AggregateStateTypeInfo());
 	deserializer.ReadProperty(200, "function_name", result->state_type.function_name);
 	deserializer.ReadProperty(201, "return_type", result->state_type.return_type);
@@ -67,58 +67,58 @@ shared_ptr<ExtraTypeInfo> AggregateStateTypeInfo::FormatDeserialize(FormatDeseri
 	return std::move(result);
 }
 
-void DecimalTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ExtraTypeInfo::FormatSerialize(serializer);
+void DecimalTypeInfo::Serialize(Serializer &serializer) const {
+	ExtraTypeInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "width", width);
 	serializer.WriteProperty(201, "scale", scale);
 }
 
-shared_ptr<ExtraTypeInfo> DecimalTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+shared_ptr<ExtraTypeInfo> DecimalTypeInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::shared_ptr<DecimalTypeInfo>(new DecimalTypeInfo());
 	deserializer.ReadProperty(200, "width", result->width);
 	deserializer.ReadProperty(201, "scale", result->scale);
 	return std::move(result);
 }
 
-void ListTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ExtraTypeInfo::FormatSerialize(serializer);
+void ListTypeInfo::Serialize(Serializer &serializer) const {
+	ExtraTypeInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "child_type", child_type);
 }
 
-shared_ptr<ExtraTypeInfo> ListTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+shared_ptr<ExtraTypeInfo> ListTypeInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::shared_ptr<ListTypeInfo>(new ListTypeInfo());
 	deserializer.ReadProperty(200, "child_type", result->child_type);
 	return std::move(result);
 }
 
-void StringTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ExtraTypeInfo::FormatSerialize(serializer);
+void StringTypeInfo::Serialize(Serializer &serializer) const {
+	ExtraTypeInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "collation", collation);
 }
 
-shared_ptr<ExtraTypeInfo> StringTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+shared_ptr<ExtraTypeInfo> StringTypeInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::shared_ptr<StringTypeInfo>(new StringTypeInfo());
 	deserializer.ReadProperty(200, "collation", result->collation);
 	return std::move(result);
 }
 
-void StructTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ExtraTypeInfo::FormatSerialize(serializer);
+void StructTypeInfo::Serialize(Serializer &serializer) const {
+	ExtraTypeInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "child_types", child_types);
 }
 
-shared_ptr<ExtraTypeInfo> StructTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+shared_ptr<ExtraTypeInfo> StructTypeInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::shared_ptr<StructTypeInfo>(new StructTypeInfo());
 	deserializer.ReadProperty(200, "child_types", result->child_types);
 	return std::move(result);
 }
 
-void UserTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ExtraTypeInfo::FormatSerialize(serializer);
+void UserTypeInfo::Serialize(Serializer &serializer) const {
+	ExtraTypeInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "user_type_name", user_type_name);
 }
 
-shared_ptr<ExtraTypeInfo> UserTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+shared_ptr<ExtraTypeInfo> UserTypeInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::shared_ptr<UserTypeInfo>(new UserTypeInfo());
 	deserializer.ReadProperty(200, "user_type_name", result->user_type_name);
 	return std::move(result);

package/src/duckdb/src/storage/single_file_block_manager.cpp

@@ -3,9 +3,7 @@
 #include "duckdb/common/allocator.hpp"
 #include "duckdb/common/checksum.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
-#include "duckdb/common/serializer/buffered_serializer.hpp"
-#include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/memory_stream.hpp"
 #include "duckdb/storage/metadata/metadata_reader.hpp"
 #include "duckdb/storage/metadata/metadata_writer.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
@@ -18,14 +16,12 @@ namespace duckdb {
 
 const char MainHeader::MAGIC_BYTES[] = "DUCK";
 
-void MainHeader::Serialize(Serializer &ser) {
+void MainHeader::Write(WriteStream &ser) {
 	ser.WriteData(const_data_ptr_cast(MAGIC_BYTES), MAGIC_BYTE_SIZE);
 	ser.Write<uint64_t>(version_number);
-	FieldWriter writer(ser);
 	for (idx_t i = 0; i < FLAG_COUNT; i++) {
-		writer.WriteField<uint64_t>(flags[i]);
+		ser.Write<uint64_t>(flags[i]);
 	}
-	writer.Finalize();
 }
 
 void MainHeader::CheckMagicBytes(FileHandle &handle) {
@@ -39,7 +35,7 @@ void MainHeader::CheckMagicBytes(FileHandle &handle) {
 	}
 }
 
-MainHeader MainHeader::Deserialize(Deserializer &source) {
+MainHeader MainHeader::Read(ReadStream &source) {
 	data_t magic_bytes[MAGIC_BYTE_SIZE];
 	MainHeader header;
 	source.ReadData(magic_bytes, MainHeader::MAGIC_BYTE_SIZE);
@@ -71,22 +67,20 @@ MainHeader MainHeader::Deserialize(Deserializer &source) {
 		    header.version_number, VERSION_NUMBER, version_text);
 	}
 	// read the flags
-	FieldReader reader(source);
 	for (idx_t i = 0; i < FLAG_COUNT; i++) {
-		header.flags[i] = reader.ReadRequired<uint64_t>();
+		header.flags[i] = source.Read<uint64_t>();
 	}
-	reader.Finalize();
 	return header;
 }
 
-void DatabaseHeader::Serialize(Serializer &ser) {
+void DatabaseHeader::Write(WriteStream &ser) {
 	ser.Write<uint64_t>(iteration);
 	ser.Write<idx_t>(meta_block);
 	ser.Write<idx_t>(free_list);
 	ser.Write<uint64_t>(block_count);
 }
 
-DatabaseHeader DatabaseHeader::Deserialize(Deserializer &source) {
+DatabaseHeader DatabaseHeader::Read(ReadStream &source) {
 	DatabaseHeader header;
 	header.iteration = source.Read<uint64_t>();
 	header.meta_block = source.Read<idx_t>();
@@ -97,14 +91,14 @@ DatabaseHeader DatabaseHeader::Deserialize(Deserializer &source) {
 
 template <class T>
 void SerializeHeaderStructure(T header, data_ptr_t ptr) {
-	BufferedSerializer ser(ptr, Storage::FILE_HEADER_SIZE);
-	header.Serialize(ser);
+	MemoryStream ser(ptr, Storage::FILE_HEADER_SIZE);
+	header.Write(ser);
 }
 
 template <class T>
 T DeserializeHeaderStructure(data_ptr_t ptr) {
-	BufferedDeserializer source(ptr, Storage::FILE_HEADER_SIZE);
-	return T::Deserialize(source);
+	MemoryStream source(ptr, Storage::FILE_HEADER_SIZE);
+	return T::Read(source);
 }
 
 SingleFileBlockManager::SingleFileBlockManager(AttachedDatabase &db, string path_p, StorageManagerOptions options)
@@ -246,6 +240,7 @@ void SingleFileBlockManager::LoadFreeList() {
 		// no free list
 		return;
 	}
+
 	MetadataReader reader(GetMetadataManager(), free_pointer, BlockReaderType::REGISTER_BLOCKS);
 	auto free_list_count = reader.Read<uint64_t>();
 	free_list.clear();
@@ -259,7 +254,7 @@ void SingleFileBlockManager::LoadFreeList() {
 		auto usage_count = reader.Read<uint32_t>();
 		multi_use_blocks[block_id] = usage_count;
 	}
-	GetMetadataManager().Deserialize(reader);
+	GetMetadataManager().Read(reader);
 	GetMetadataManager().MarkBlocksAsModified();
 }
 
@@ -466,7 +461,7 @@ void SingleFileBlockManager::WriteHeader(DatabaseHeader header) {
 			writer.Write<block_id_t>(entry.first);
 			writer.Write<uint32_t>(entry.second);
 		}
-		GetMetadataManager().Serialize(writer);
+		GetMetadataManager().Write(writer);
 		writer.Flush();
 	} else {
 		// no blocks in the free list
@@ -487,9 +482,9 @@ void SingleFileBlockManager::WriteHeader(DatabaseHeader header) {
 	}
 	// set the header inside the buffer
 	header_buffer.Clear();
-	BufferedSerializer serializer;
-	header.Serialize(serializer);
-	memcpy(header_buffer.buffer, serializer.blob.data.get(), serializer.blob.size);
+	MemoryStream serializer;
+	header.Write(serializer);
+	memcpy(header_buffer.buffer, serializer.GetData(), serializer.GetPosition());
 	// now write the header to the file, active_header determines whether we write to h1 or h2
 	// note that if active_header is h1 we write to h2, and vice versa
 	ChecksumAndWrite(header_buffer, active_header == 1 ? Storage::FILE_HEADER_SIZE : Storage::FILE_HEADER_SIZE * 2);