duckdb 0.8.2-dev4126.0 → 0.8.2-dev4203.0

package/src/duckdb/src/storage/statistics/base_statistics.cpp

@@ -1,13 +1,12 @@
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/storage/statistics/list_stats.hpp"
 #include "duckdb/storage/statistics/struct_stats.hpp"
 
-#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"
 
 namespace duckdb {
 
@@ -275,59 +274,30 @@ void BaseStatistics::SetDistinctCount(idx_t count) {
 }
 
 void BaseStatistics::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<bool>(has_null);
-	writer.WriteField<bool>(has_no_null);
-	writer.WriteField<idx_t>(distinct_count);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-void BaseStatistics::Serialize(FieldWriter &writer) const {
-	switch (GetStatsType()) {
-	case StatisticsType::NUMERIC_STATS:
-		NumericStats::Serialize(*this, writer);
-		break;
-	case StatisticsType::STRING_STATS:
-		StringStats::Serialize(*this, writer);
-		break;
-	case StatisticsType::LIST_STATS:
-		ListStats::Serialize(*this, writer);
-		break;
-	case StatisticsType::STRUCT_STATS:
-		StructStats::Serialize(*this, writer);
-		break;
-	default:
-		break;
-	}
-}
-
-void BaseStatistics::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(100, "has_null", has_null);
 	serializer.WriteProperty(101, "has_no_null", has_no_null);
 	serializer.WriteProperty(102, "distinct_count", distinct_count);
-	serializer.WriteProperty(103, "stats_type", GetStatsType());
-	serializer.WriteObject(104, "stats", [this](FormatSerializer &serializer) {
+	serializer.WriteObject(103, "type_stats", [&](Serializer &serializer) {
 		switch (GetStatsType()) {
 		case StatisticsType::NUMERIC_STATS:
-			NumericStats::FormatSerialize(*this, serializer);
+			NumericStats::Serialize(*this, serializer);
 			break;
 		case StatisticsType::STRING_STATS:
-			StringStats::FormatSerialize(*this, serializer);
+			StringStats::Serialize(*this, serializer);
 			break;
 		case StatisticsType::LIST_STATS:
-			ListStats::FormatSerialize(*this, serializer);
+			ListStats::Serialize(*this, serializer);
 			break;
 		case StatisticsType::STRUCT_STATS:
-			StructStats::FormatSerialize(*this, serializer);
+			StructStats::Serialize(*this, serializer);
 			break;
 		default:
-			throw NotImplementedException("Unrecognized StatisticsType for BaseStatistics::FormatSerialize");
+			break;
 		}
 	});
 }
 
-BaseStatistics BaseStatistics::FormatDeserialize(FormatDeserializer &deserializer) {
+BaseStatistics BaseStatistics::Deserialize(Deserializer &deserializer) {
 	auto has_null = deserializer.ReadProperty<bool>(100, "has_null");
 	auto has_no_null = deserializer.ReadProperty<bool>(101, "has_no_null");
 	auto distinct_count = deserializer.ReadProperty<idx_t>(102, "distinct_count");
@@ -335,58 +305,34 @@ BaseStatistics BaseStatistics::FormatDeserialize(FormatDeserializer &deserialize
 	// Get the logical type from the deserializer context.
 	auto type = deserializer.Get<LogicalType &>();
 
-	BaseStatistics stats;
-	switch (GetStatsType(type)) {
-	case StatisticsType::NUMERIC_STATS:
-		stats = NumericStats::FormatDeserialize(deserializer, type);
-		break;
-	case StatisticsType::STRING_STATS:
-		stats = StringStats::FormatDeserialize(deserializer, type);
-		break;
-	case StatisticsType::LIST_STATS:
-		stats = ListStats::FormatDeserialize(deserializer, type);
-		break;
-	case StatisticsType::STRUCT_STATS:
-		stats = StructStats::FormatDeserialize(deserializer, type);
-		break;
-	default:
-		stats = BaseStatistics(std::move(type));
-		break;
-	}
+	auto stats_type = GetStatsType(type);
+
+	BaseStatistics stats(std::move(type));
 
 	stats.has_null = has_null;
 	stats.has_no_null = has_no_null;
 	stats.distinct_count = distinct_count;
 
-	return stats;
-}
-
-BaseStatistics BaseStatistics::DeserializeType(FieldReader &reader, LogicalType type) {
-	switch (GetStatsType(type)) {
-	case StatisticsType::NUMERIC_STATS:
-		return NumericStats::Deserialize(reader, std::move(type));
-	case StatisticsType::STRING_STATS:
-		return StringStats::Deserialize(reader, std::move(type));
-	case StatisticsType::LIST_STATS:
-		return ListStats::Deserialize(reader, std::move(type));
-	case StatisticsType::STRUCT_STATS:
-		return StructStats::Deserialize(reader, std::move(type));
-	default:
-		return BaseStatistics(std::move(type));
-	}
-}
+	deserializer.ReadObject(103, "type_stats", [&](Deserializer &obj) {
+		switch (stats_type) {
+		case StatisticsType::NUMERIC_STATS:
+			NumericStats::Deserialize(obj, stats);
+			break;
+		case StatisticsType::STRING_STATS:
+			StringStats::Deserialize(obj, stats);
+			break;
+		case StatisticsType::LIST_STATS:
+			ListStats::Deserialize(obj, stats);
+			break;
+		case StatisticsType::STRUCT_STATS:
+			StructStats::Deserialize(obj, stats);
+			break;
+		default:
+			break;
+		}
+	});
 
-BaseStatistics BaseStatistics::Deserialize(Deserializer &source, LogicalType type) {
-	FieldReader reader(source);
-	bool has_null = reader.ReadRequired<bool>();
-	bool has_no_null = reader.ReadRequired<bool>();
-	idx_t distinct_count = reader.ReadRequired<idx_t>();
-	auto result = DeserializeType(reader, std::move(type));
-	result.has_null = has_null;
-	result.has_no_null = has_no_null;
-	result.distinct_count = distinct_count;
-	reader.Finalize();
-	return result;
+	return stats;
 }
 
 string BaseStatistics::ToString() const {

package/src/duckdb/src/storage/statistics/column_statistics.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/storage/statistics/column_statistics.hpp"
-#include "duckdb/common/serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
 
 namespace duckdb {
 
@@ -55,29 +54,17 @@ void ColumnStatistics::UpdateDistinctStatistics(Vector &v, idx_t count) {
 shared_ptr<ColumnStatistics> ColumnStatistics::Copy() const {
 	return make_shared<ColumnStatistics>(stats.Copy(), distinct_stats ? distinct_stats->Copy() : nullptr);
 }
-void ColumnStatistics::Serialize(Serializer &serializer) const {
-	stats.Serialize(serializer);
-	serializer.WriteOptional(distinct_stats);
-}
 
-shared_ptr<ColumnStatistics> ColumnStatistics::Deserialize(Deserializer &source, const LogicalType &type) {
-	auto stats = BaseStatistics::Deserialize(source, type);
-	auto distinct_stats = source.ReadOptional<DistinctStatistics>();
-	return make_shared<ColumnStatistics>(stats.Copy(), std::move(distinct_stats));
-}
-
-void ColumnStatistics::FormatSerialize(FormatSerializer &serializer) const {
+void ColumnStatistics::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "statistics", stats);
 	serializer.WritePropertyWithDefault(101, "distinct", distinct_stats, unique_ptr<DistinctStatistics>());
 }
 
-shared_ptr<ColumnStatistics> ColumnStatistics::FormatDeserialize(FormatDeserializer &deserializer) {
-	// TODO: do we read this as an property or into the object itself?
-	// we have this sort of pseudo inheritance going on here which is annoying
-	auto stats = BaseStatistics::FormatDeserialize(deserializer);
+shared_ptr<ColumnStatistics> ColumnStatistics::Deserialize(Deserializer &deserializer) {
+	auto stats = deserializer.ReadProperty<BaseStatistics>(100, "statistics");
 	auto distinct_stats = deserializer.ReadPropertyWithDefault<unique_ptr<DistinctStatistics>>(
 	    101, "distinct", unique_ptr<DistinctStatistics>());
-	return make_shared<ColumnStatistics>(stats.Copy(), std::move(distinct_stats));
+	return make_shared<ColumnStatistics>(std::move(stats), std::move(distinct_stats));
 }
 
 } // namespace duckdb

package/src/duckdb/src/storage/statistics/distinct_statistics.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/storage/statistics/distinct_statistics.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 
 #include <math.h>
@@ -24,31 +23,6 @@ void DistinctStatistics::Merge(const DistinctStatistics &other) {
 	total_count += other.total_count;
 }
 
-void DistinctStatistics::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-void DistinctStatistics::Serialize(FieldWriter &writer) const {
-	writer.WriteField<idx_t>(sample_count);
-	writer.WriteField<idx_t>(total_count);
-	log->Serialize(writer);
-}
-
-unique_ptr<DistinctStatistics> DistinctStatistics::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto result = Deserialize(reader);
-	reader.Finalize();
-	return result;
-}
-
-unique_ptr<DistinctStatistics> DistinctStatistics::Deserialize(FieldReader &reader) {
-	auto sample_count = reader.ReadRequired<idx_t>();
-	auto total_count = reader.ReadRequired<idx_t>();
-	return make_uniq<DistinctStatistics>(HyperLogLog::Deserialize(reader), sample_count, total_count);
-}
-
 void DistinctStatistics::Update(Vector &v, idx_t count, bool sample) {
 	UnifiedVectorFormat vdata;
 	v.ToUnifiedFormat(count, vdata);

package/src/duckdb/src/storage/statistics/list_stats.cpp

@@ -1,11 +1,10 @@
 #include "duckdb/storage/statistics/list_stats.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/vector.hpp"
 
-#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"
 
 namespace duckdb {
 
@@ -69,35 +68,20 @@ void ListStats::Merge(BaseStatistics &stats, const BaseStatistics &other) {
 	child_stats.Merge(other_child_stats);
 }
 
-void ListStats::Serialize(const BaseStatistics &stats, FieldWriter &writer) {
-	auto &child_stats = ListStats::GetChildStats(stats);
-	writer.WriteSerializable(child_stats);
-}
-
-BaseStatistics ListStats::Deserialize(FieldReader &reader, LogicalType type) {
-	D_ASSERT(type.InternalType() == PhysicalType::LIST);
-	auto &child_type = ListType::GetChildType(type);
-	BaseStatistics result(std::move(type));
-	result.child_stats[0].Copy(reader.ReadRequiredSerializable<BaseStatistics, BaseStatistics>(child_type));
-	return result;
-}
-
-void ListStats::FormatSerialize(const BaseStatistics &stats, FormatSerializer &serializer) {
+void ListStats::Serialize(const BaseStatistics &stats, Serializer &serializer) {
 	auto &child_stats = ListStats::GetChildStats(stats);
 	serializer.WriteProperty(200, "child_stats", child_stats);
 }
 
-BaseStatistics ListStats::FormatDeserialize(FormatDeserializer &deserializer, LogicalType type) {
+void ListStats::Deserialize(Deserializer &deserializer, BaseStatistics &base) {
+	auto &type = base.GetType();
 	D_ASSERT(type.InternalType() == PhysicalType::LIST);
 	auto &child_type = ListType::GetChildType(type);
-	BaseStatistics result(std::move(type));
 
 	// Push the logical type of the child type to the deserialization context
 	deserializer.Set<LogicalType &>(const_cast<LogicalType &>(child_type));
-	result.child_stats[0].Copy(deserializer.ReadProperty<BaseStatistics>(200, "child_stats"));
+	base.child_stats[0].Copy(deserializer.ReadProperty<BaseStatistics>(200, "child_stats"));
 	deserializer.Unset<LogicalType>();
-
-	return result;
 }
 
 string ListStats::ToString(const BaseStatistics &stats) {

package/src/duckdb/src/storage/statistics/numeric_stats.cpp

@@ -1,11 +1,10 @@
 #include "duckdb/storage/statistics/numeric_stats.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
 
-#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"
 
 namespace duckdb {
 
@@ -407,119 +406,7 @@ Value NumericStats::MaxOrNull(const BaseStatistics &stats) {
 }
 
 static void SerializeNumericStatsValue(const LogicalType &type, NumericValueUnion val, bool has_value,
-                                       FieldWriter &writer) {
-	writer.WriteField<bool>(!has_value);
-	if (!has_value) {
-		return;
-	}
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		writer.WriteField<bool>(val.value_.boolean);
-		break;
-	case PhysicalType::INT8:
-		writer.WriteField<int8_t>(val.value_.tinyint);
-		break;
-	case PhysicalType::INT16:
-		writer.WriteField<int16_t>(val.value_.smallint);
-		break;
-	case PhysicalType::INT32:
-		writer.WriteField<int32_t>(val.value_.integer);
-		break;
-	case PhysicalType::INT64:
-		writer.WriteField<int64_t>(val.value_.bigint);
-		break;
-	case PhysicalType::UINT8:
-		writer.WriteField<int8_t>(val.value_.utinyint);
-		break;
-	case PhysicalType::UINT16:
-		writer.WriteField<int16_t>(val.value_.usmallint);
-		break;
-	case PhysicalType::UINT32:
-		writer.WriteField<int32_t>(val.value_.uinteger);
-		break;
-	case PhysicalType::UINT64:
-		writer.WriteField<int64_t>(val.value_.ubigint);
-		break;
-	case PhysicalType::INT128:
-		writer.WriteField<hugeint_t>(val.value_.hugeint);
-		break;
-	case PhysicalType::FLOAT:
-		writer.WriteField<float>(val.value_.float_);
-		break;
-	case PhysicalType::DOUBLE:
-		writer.WriteField<double>(val.value_.double_);
-		break;
-	default:
-		throw InternalException("Unsupported type for serializing numeric statistics");
-	}
-}
-
-void NumericStats::Serialize(const BaseStatistics &stats, FieldWriter &writer) {
-	auto &numeric_stats = NumericStats::GetDataUnsafe(stats);
-	SerializeNumericStatsValue(stats.GetType(), numeric_stats.min, numeric_stats.has_min, writer);
-	SerializeNumericStatsValue(stats.GetType(), numeric_stats.max, numeric_stats.has_max, writer);
-}
-
-void DeserializeNumericStatsValue(const LogicalType &type, FieldReader &reader, NumericValueUnion &result,
-                                  bool &has_stats) {
-	auto is_null = reader.ReadRequired<bool>();
-	if (is_null) {
-		has_stats = false;
-		return;
-	}
-	has_stats = true;
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		result.value_.boolean = reader.ReadRequired<bool>();
-		break;
-	case PhysicalType::INT8:
-		result.value_.tinyint = reader.ReadRequired<int8_t>();
-		break;
-	case PhysicalType::INT16:
-		result.value_.smallint = reader.ReadRequired<int16_t>();
-		break;
-	case PhysicalType::INT32:
-		result.value_.integer = reader.ReadRequired<int32_t>();
-		break;
-	case PhysicalType::INT64:
-		result.value_.bigint = reader.ReadRequired<int64_t>();
-		break;
-	case PhysicalType::UINT8:
-		result.value_.utinyint = reader.ReadRequired<uint8_t>();
-		break;
-	case PhysicalType::UINT16:
-		result.value_.usmallint = reader.ReadRequired<uint16_t>();
-		break;
-	case PhysicalType::UINT32:
-		result.value_.uinteger = reader.ReadRequired<uint32_t>();
-		break;
-	case PhysicalType::UINT64:
-		result.value_.ubigint = reader.ReadRequired<uint64_t>();
-		break;
-	case PhysicalType::INT128:
-		result.value_.hugeint = reader.ReadRequired<hugeint_t>();
-		break;
-	case PhysicalType::FLOAT:
-		result.value_.float_ = reader.ReadRequired<float>();
-		break;
-	case PhysicalType::DOUBLE:
-		result.value_.double_ = reader.ReadRequired<double>();
-		break;
-	default:
-		throw InternalException("Unsupported type for deserializing numeric statistics");
-	}
-}
-
-BaseStatistics NumericStats::Deserialize(FieldReader &reader, LogicalType type) {
-	BaseStatistics result(std::move(type));
-	auto &numeric_stats = NumericStats::GetDataUnsafe(result);
-	DeserializeNumericStatsValue(result.GetType(), reader, numeric_stats.min, numeric_stats.has_min);
-	DeserializeNumericStatsValue(result.GetType(), reader, numeric_stats.max, numeric_stats.has_max);
-	return result;
-}
-
-static void FormatSerializeNumericStatsValue(const LogicalType &type, NumericValueUnion val, bool has_value,
-                                             FormatSerializer &serializer) {
+                                       Serializer &serializer) {
 	serializer.WriteProperty(100, "has_value", has_value);
 	if (!has_value) {
 		return;
@@ -566,18 +453,8 @@ static void FormatSerializeNumericStatsValue(const LogicalType &type, NumericVal
 	}
 }
 
-void NumericStats::FormatSerialize(const BaseStatistics &stats, FormatSerializer &serializer) {
-	auto &numeric_stats = NumericStats::GetDataUnsafe(stats);
-	serializer.WriteObject(200, "max", [&](FormatSerializer &object) {
-		FormatSerializeNumericStatsValue(stats.GetType(), numeric_stats.min, numeric_stats.has_min, object);
-	});
-	serializer.WriteObject(201, "min", [&](FormatSerializer &object) {
-		FormatSerializeNumericStatsValue(stats.GetType(), numeric_stats.max, numeric_stats.has_max, object);
-	});
-}
-
-static void FormatDeserializeNumericStatsValue(const LogicalType &type, NumericValueUnion &result, bool &has_stats,
-                                               FormatDeserializer &deserializer) {
+static void DeserializeNumericStatsValue(const LogicalType &type, NumericValueUnion &result, bool &has_stats,
+                                         Deserializer &deserializer) {
 	auto has_value = deserializer.ReadProperty<bool>(100, "has_value");
 	if (!has_value) {
 		has_stats = false;
@@ -626,17 +503,25 @@ static void FormatDeserializeNumericStatsValue(const LogicalType &type, NumericV
 	}
 }
 
-BaseStatistics NumericStats::FormatDeserialize(FormatDeserializer &deserializer, LogicalType type) {
-	BaseStatistics result(std::move(type));
+void NumericStats::Serialize(const BaseStatistics &stats, Serializer &serializer) {
+	auto &numeric_stats = NumericStats::GetDataUnsafe(stats);
+	serializer.WriteObject(200, "max", [&](Serializer &object) {
+		SerializeNumericStatsValue(stats.GetType(), numeric_stats.min, numeric_stats.has_min, object);
+	});
+	serializer.WriteObject(201, "min", [&](Serializer &object) {
+		SerializeNumericStatsValue(stats.GetType(), numeric_stats.max, numeric_stats.has_max, object);
+	});
+}
+
+void NumericStats::Deserialize(Deserializer &deserializer, BaseStatistics &result) {
 	auto &numeric_stats = NumericStats::GetDataUnsafe(result);
 
-	deserializer.ReadObject(200, "max", [&](FormatDeserializer &object) {
-		FormatDeserializeNumericStatsValue(result.GetType(), numeric_stats.min, numeric_stats.has_min, object);
+	deserializer.ReadObject(200, "max", [&](Deserializer &object) {
+		DeserializeNumericStatsValue(result.GetType(), numeric_stats.min, numeric_stats.has_min, object);
 	});
-	deserializer.ReadObject(201, "min", [&](FormatDeserializer &object) {
-		FormatDeserializeNumericStatsValue(result.GetType(), numeric_stats.max, numeric_stats.has_max, object);
+	deserializer.ReadObject(201, "min", [&](Deserializer &object) {
+		DeserializeNumericStatsValue(result.GetType(), numeric_stats.max, numeric_stats.has_max, object);
 	});
-	return result;
 }
 
 string NumericStats::ToString(const BaseStatistics &stats) {

package/src/duckdb/src/storage/statistics/string_stats.cpp

@@ -1,14 +1,13 @@
 #include "duckdb/storage/statistics/string_stats.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/main/error_manager.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "utf8proc_wrapper.hpp"
 
-#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"
 
 namespace duckdb {
 
@@ -97,16 +96,7 @@ void StringStats::SetContainsUnicode(BaseStatistics &stats) {
 	StringStats::GetDataUnsafe(stats).has_unicode = true;
 }
 
-void StringStats::Serialize(const BaseStatistics &stats, FieldWriter &writer) {
-	auto &string_data = StringStats::GetDataUnsafe(stats);
-	writer.WriteBlob(string_data.min, StringStatsData::MAX_STRING_MINMAX_SIZE);
-	writer.WriteBlob(string_data.max, StringStatsData::MAX_STRING_MINMAX_SIZE);
-	writer.WriteField<bool>(string_data.has_unicode);
-	writer.WriteField<bool>(string_data.has_max_string_length);
-	writer.WriteField<uint32_t>(string_data.max_string_length);
-}
-
-void StringStats::FormatSerialize(const BaseStatistics &stats, FormatSerializer &serializer) {
+void StringStats::Serialize(const BaseStatistics &stats, Serializer &serializer) {
 	auto &string_data = StringStats::GetDataUnsafe(stats);
 	serializer.WriteProperty(200, "min", string_data.min, StringStatsData::MAX_STRING_MINMAX_SIZE);
 	serializer.WriteProperty(201, "max", string_data.max, StringStatsData::MAX_STRING_MINMAX_SIZE);
@@ -115,26 +105,13 @@ void StringStats::FormatSerialize(const BaseStatistics &stats, FormatSerializer
 	serializer.WriteProperty(204, "max_string_length", string_data.max_string_length);
 }
 
-BaseStatistics StringStats::Deserialize(FieldReader &reader, LogicalType type) {
-	BaseStatistics result(std::move(type));
-	auto &string_data = StringStats::GetDataUnsafe(result);
-	reader.ReadBlob(string_data.min, StringStatsData::MAX_STRING_MINMAX_SIZE);
-	reader.ReadBlob(string_data.max, StringStatsData::MAX_STRING_MINMAX_SIZE);
-	string_data.has_unicode = reader.ReadRequired<bool>();
-	string_data.has_max_string_length = reader.ReadRequired<bool>();
-	string_data.max_string_length = reader.ReadRequired<uint32_t>();
-	return result;
-}
-
-BaseStatistics StringStats::FormatDeserialize(FormatDeserializer &deserializer, LogicalType type) {
-	BaseStatistics result(std::move(type));
-	auto &string_data = StringStats::GetDataUnsafe(result);
+void StringStats::Deserialize(Deserializer &deserializer, BaseStatistics &base) {
+	auto &string_data = StringStats::GetDataUnsafe(base);
 	deserializer.ReadProperty(200, "min", string_data.min, StringStatsData::MAX_STRING_MINMAX_SIZE);
 	deserializer.ReadProperty(201, "max", string_data.max, StringStatsData::MAX_STRING_MINMAX_SIZE);
 	deserializer.ReadProperty(202, "has_unicode", string_data.has_unicode);
 	deserializer.ReadProperty(203, "has_max_string_length", string_data.has_max_string_length);
 	deserializer.ReadProperty(204, "max_string_length", string_data.max_string_length);
-	return result;
 }
 
 static int StringValueComparison(const_data_ptr_t data, idx_t len, const_data_ptr_t comparison) {

package/src/duckdb/src/storage/statistics/struct_stats.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/storage/statistics/struct_stats.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/vector.hpp"
 
-#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"
 
 namespace duckdb {
 
@@ -93,47 +92,26 @@ void StructStats::Merge(BaseStatistics &stats, const BaseStatistics &other) {
 	}
 }
 
-void StructStats::Serialize(const BaseStatistics &stats, FieldWriter &writer) {
-	auto child_stats = StructStats::GetChildStats(stats);
-	auto child_count = StructType::GetChildCount(stats.GetType());
-	for (idx_t i = 0; i < child_count; i++) {
-		writer.WriteSerializable(child_stats[i]);
-	}
-}
-
-BaseStatistics StructStats::Deserialize(FieldReader &reader, LogicalType type) {
-	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
-	auto &child_types = StructType::GetChildTypes(type);
-	BaseStatistics result(std::move(type));
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		result.child_stats[i].Copy(
-		    reader.ReadRequiredSerializable<BaseStatistics, BaseStatistics>(child_types[i].second));
-	}
-	return result;
-}
-
-void StructStats::FormatSerialize(const BaseStatistics &stats, FormatSerializer &serializer) {
+void StructStats::Serialize(const BaseStatistics &stats, Serializer &serializer) {
 	auto child_stats = StructStats::GetChildStats(stats);
 	auto child_count = StructType::GetChildCount(stats.GetType());
 
 	serializer.WriteList(200, "child_stats", child_count,
-	                     [&](FormatSerializer::List &list, idx_t i) { list.WriteElement(child_stats[i]); });
+	                     [&](Serializer::List &list, idx_t i) { list.WriteElement(child_stats[i]); });
 }
 
-BaseStatistics StructStats::FormatDeserialize(FormatDeserializer &deserializer, LogicalType type) {
+void StructStats::Deserialize(Deserializer &deserializer, BaseStatistics &base) {
+	auto &type = base.GetType();
 	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
 
 	auto &child_types = StructType::GetChildTypes(type);
-	BaseStatistics result(std::move(type));
 
-	deserializer.ReadList(200, "child_stats", [&](FormatDeserializer::List &list, idx_t i) {
+	deserializer.ReadList(200, "child_stats", [&](Deserializer::List &list, idx_t i) {
 		deserializer.Set<LogicalType &>(const_cast<LogicalType &>(child_types[i].second));
 		auto stat = list.ReadElement<BaseStatistics>();
-		result.child_stats[i].Copy(stat);
+		base.child_stats[i].Copy(stat);
 		deserializer.Unset<LogicalType>();
 	});
-
-	return result;
 }
 
 string StructStats::ToString(const BaseStatistics &stats) {

package/src/duckdb/src/storage/storage_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 58;
+const uint64_t VERSION_NUMBER = 59;
 
 struct StorageVersionInfo {
 	const char *version_name;