duckdb 0.8.2-dev4142.0 → 0.8.2-dev4314.0

package/src/duckdb/src/include/duckdb/planner/operator/logical_simple.hpp

@@ -26,11 +26,8 @@ public:
 	unique_ptr<ParseInfo> info;
 
 public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
-
-	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_top_n.hpp

@@ -33,11 +33,9 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override {
 		return children[0]->GetColumnBindings();
 	}
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
-	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 
 	idx_t EstimateCardinality(ClientContext &context) override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_unnest.hpp

@@ -26,10 +26,8 @@ public:
 
 public:
 	vector<ColumnBinding> GetColumnBindings() override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
-	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_update.hpp

@@ -31,10 +31,8 @@ public:
 	bool update_is_del_and_insert;
 
 public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
-	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 
 	idx_t EstimateCardinality(ClientContext &context) override;
 	string GetName() const override;

package/src/duckdb/src/include/duckdb/planner/operator/logical_window.hpp

@@ -27,11 +27,9 @@ public:
 
 public:
 	vector<ColumnBinding> GetColumnBindings() override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
-	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator_extension.hpp

@@ -34,9 +34,7 @@ public:
 	shared_ptr<OperatorExtensionInfo> operator_info;
 
 	virtual std::string GetName() = 0;
-	virtual unique_ptr<LogicalExtensionOperator> Deserialize(LogicalDeserializationState &state,
-	                                                         FieldReader &reader) = 0;
-	virtual unique_ptr<LogicalExtensionOperator> FormatDeserialize(FormatDeserializer &deserializer) = 0;
+	virtual unique_ptr<LogicalExtensionOperator> Deserialize(Deserializer &deserializer) = 0;
 
 	virtual ~OperatorExtension() {
 	}

package/src/duckdb/src/include/duckdb/planner/parsed_data/bound_create_table_info.hpp

@@ -49,11 +49,6 @@ struct BoundCreateTableInfo {
 	//! Indexes created by this table <Block_ID, Offset>
 	vector<BlockPointer> indexes;
 
-	//! Serializes a BoundCreateTableInfo to a stand-alone binary blob
-	void Serialize(Serializer &serializer) const;
-	//! Deserializes a blob back into a BoundCreateTableInfo
-	static unique_ptr<BoundCreateTableInfo> Deserialize(Deserializer &source, PlanDeserializationState &state);
-
 	CreateTableInfo &Base() {
 		D_ASSERT(base);
 		return (CreateTableInfo &)*base;

package/src/duckdb/src/include/duckdb/planner/table_filter.hpp

@@ -15,8 +15,6 @@
 
 namespace duckdb {
 class BaseStatistics;
-class FieldWriter;
-class FieldReader;
 
 enum class TableFilterType : uint8_t {
 	CONSTANT_COMPARISON = 0, // constant comparison (e.g. =C, >C, >=C, <C, <=C)
@@ -44,12 +42,8 @@ public:
 		return filter_type != other.filter_type;
 	}
 
-	void Serialize(Serializer &serializer) const;
-	virtual void Serialize(FieldWriter &writer) const = 0;
-	static unique_ptr<TableFilter> Deserialize(Deserializer &source);
-
-	virtual void FormatSerialize(FormatSerializer &serializer) const;
-	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
+	virtual void Serialize(Serializer &serializer) const;
+	static unique_ptr<TableFilter> Deserialize(Deserializer &deserializer);
 
 public:
 	template <class TARGET>
@@ -102,10 +96,7 @@ public:
 	}
 
 	void Serialize(Serializer &serializer) const;
-	static unique_ptr<TableFilterSet> Deserialize(Deserializer &source);
-
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static TableFilterSet FormatDeserialize(FormatDeserializer &deserializer);
+	static TableFilterSet Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/tableref/bound_pivotref.hpp

@@ -26,8 +26,8 @@ struct BoundPivotInfo {
 	//! The set of aggregate functions that is being executed
 	vector<unique_ptr<Expression>> aggregates;
 
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static BoundPivotInfo FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static BoundPivotInfo Deserialize(Deserializer &deserializer);
 };
 
 class BoundPivotRef : public BoundTableRef {

package/src/duckdb/src/include/duckdb/storage/block.hpp

@@ -14,8 +14,8 @@
 
 namespace duckdb {
 
-class FormatSerializer;
-class FormatDeserializer;
+class Serializer;
+class Deserializer;
 
 class Block : public FileBuffer {
 public:
@@ -38,6 +38,9 @@ struct BlockPointer {
 	bool IsValid() const {
 		return block_id != INVALID_BLOCK;
 	}
+
+	void Serialize(Serializer &serializer) const;
+	static BlockPointer Deserialize(Deserializer &source);
 };
 
 struct MetaBlockPointer {
@@ -55,8 +58,8 @@ struct MetaBlockPointer {
 	block_id_t GetBlockId();
 	uint32_t GetBlockIndex();
 
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static MetaBlockPointer FormatDeserialize(FormatDeserializer &source);
+	void Serialize(Serializer &serializer) const;
+	static MetaBlockPointer Deserialize(Deserializer &source);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/checkpoint/row_group_writer.hpp

@@ -30,7 +30,7 @@ public:
 
 	CompressionType GetColumnCompressionType(idx_t i);
 
-	virtual void WriteColumnDataPointers(ColumnCheckpointState &column_checkpoint_state) = 0;
+	virtual void WriteColumnDataPointers(ColumnCheckpointState &column_checkpoint_state, Serializer &serializer) = 0;
 
 	virtual MetadataWriter &GetPayloadWriter() = 0;
 
@@ -59,7 +59,8 @@ public:
 	MetadataWriter &table_data_writer;
 
 public:
-	virtual void WriteColumnDataPointers(ColumnCheckpointState &column_checkpoint_state) override;
+	virtual void WriteColumnDataPointers(ColumnCheckpointState &column_checkpoint_state,
+	                                     Serializer &serializer) override;
 
 	virtual MetadataWriter &GetPayloadWriter() override;
 };

package/src/duckdb/src/include/duckdb/storage/checkpoint/table_data_writer.hpp

@@ -27,11 +27,12 @@ public:
 	virtual ~TableDataWriter();
 
 public:
-	void WriteTableData();
+	void WriteTableData(Serializer &metadata_serializer);
 
 	CompressionType GetColumnCompressionType(idx_t i);
 
-	virtual void FinalizeTable(TableStatistics &&global_stats, DataTableInfo *info) = 0;
+	virtual void FinalizeTable(TableStatistics &&global_stats, DataTableInfo *info,
+	                           Serializer &metadata_serializer) = 0;
 	virtual unique_ptr<RowGroupWriter> GetRowGroupWriter(RowGroup &row_group) = 0;
 
 	virtual void AddRowGroup(RowGroupPointer &&row_group_pointer, unique_ptr<RowGroupWriter> &&writer);
@@ -45,18 +46,17 @@ protected:
 class SingleFileTableDataWriter : public TableDataWriter {
 public:
 	SingleFileTableDataWriter(SingleFileCheckpointWriter &checkpoint_manager, TableCatalogEntry &table,
-	                          MetadataWriter &table_data_writer, MetadataWriter &meta_data_writer);
+	                          MetadataWriter &table_data_writer);
 
 public:
-	virtual void FinalizeTable(TableStatistics &&global_stats, DataTableInfo *info) override;
+	virtual void FinalizeTable(TableStatistics &&global_stats, DataTableInfo *info,
+	                           Serializer &metadata_serializer) override;
 	virtual unique_ptr<RowGroupWriter> GetRowGroupWriter(RowGroup &row_group) override;
 
 private:
 	SingleFileCheckpointWriter &checkpoint_manager;
 	// Writes the actual table data
 	MetadataWriter &table_data_writer;
-	// Writes the metadata of the table
-	MetadataWriter &meta_data_writer;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/checkpoint_manager.hpp

@@ -38,14 +38,14 @@ public:
 	virtual unique_ptr<TableDataWriter> GetTableDataWriter(TableCatalogEntry &table) = 0;
 
 protected:
-	virtual void WriteSchema(SchemaCatalogEntry &schema);
-	virtual void WriteTable(TableCatalogEntry &table);
-	virtual void WriteView(ViewCatalogEntry &table);
-	virtual void WriteSequence(SequenceCatalogEntry &table);
-	virtual void WriteMacro(ScalarMacroCatalogEntry &table);
-	virtual void WriteTableMacro(TableMacroCatalogEntry &table);
-	virtual void WriteIndex(IndexCatalogEntry &index_catalog);
-	virtual void WriteType(TypeCatalogEntry &type);
+	virtual void WriteSchema(SchemaCatalogEntry &schema, Serializer &serializer);
+	virtual void WriteTable(TableCatalogEntry &table, Serializer &serializer);
+	virtual void WriteView(ViewCatalogEntry &table, Serializer &serializer);
+	virtual void WriteSequence(SequenceCatalogEntry &table, Serializer &serializer);
+	virtual void WriteMacro(ScalarMacroCatalogEntry &table, Serializer &serializer);
+	virtual void WriteTableMacro(TableMacroCatalogEntry &table, Serializer &serializer);
+	virtual void WriteIndex(IndexCatalogEntry &index_catalog, Serializer &serializer);
+	virtual void WriteType(TypeCatalogEntry &type, Serializer &serializer);
 };
 
 class CheckpointReader {
@@ -60,16 +60,16 @@ protected:
 
 protected:
 	virtual void LoadCheckpoint(ClientContext &context, MetadataReader &reader);
-	virtual void ReadSchema(ClientContext &context, MetadataReader &reader);
-	virtual void ReadTable(ClientContext &context, MetadataReader &reader);
-	virtual void ReadView(ClientContext &context, MetadataReader &reader);
-	virtual void ReadSequence(ClientContext &context, MetadataReader &reader);
-	virtual void ReadMacro(ClientContext &context, MetadataReader &reader);
-	virtual void ReadTableMacro(ClientContext &context, MetadataReader &reader);
-	virtual void ReadIndex(ClientContext &context, MetadataReader &reader);
-	virtual void ReadType(ClientContext &context, MetadataReader &reader);
-
-	virtual void ReadTableData(ClientContext &context, MetadataReader &reader, BoundCreateTableInfo &bound_info);
+	virtual void ReadSchema(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadTable(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadView(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadSequence(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadMacro(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadTableMacro(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadIndex(ClientContext &context, Deserializer &deserializer);
+	virtual void ReadType(ClientContext &context, Deserializer &deserializer);
+
+	virtual void ReadTableData(ClientContext &context, Deserializer &deserializer, BoundCreateTableInfo &bound_info);
 };
 
 class SingleFileCheckpointReader final : public CheckpointReader {

package/src/duckdb/src/include/duckdb/storage/data_pointer.hpp

@@ -17,6 +17,9 @@
 
 namespace duckdb {
 
+class Serializer;
+class Deserializer;
+
 struct DataPointer {
 	DataPointer(BaseStatistics stats) : statistics(std::move(stats)) {
 	}
@@ -27,6 +30,9 @@ struct DataPointer {
 	CompressionType compression_type;
 	//! Type-specific statistics of the segment
 	BaseStatistics statistics;
+
+	void Serialize(Serializer &serializer) const;
+	static DataPointer Deserialize(Deserializer &source);
 };
 
 struct RowGroupPointer {

package/src/duckdb/src/include/duckdb/storage/data_table.hpp

@@ -175,7 +175,7 @@ public:
 	void SetDistinct(column_t column_id, unique_ptr<DistinctStatistics> distinct_stats);
 
 	//! Checkpoint the table to the specified table data writer
-	void Checkpoint(TableDataWriter &writer);
+	void Checkpoint(TableDataWriter &writer, Serializer &metadata_serializer);
 	void CommitDropTable();
 	void CommitDropColumn(idx_t index);
 

package/src/duckdb/src/include/duckdb/storage/metadata/metadata_manager.hpp

@@ -9,7 +9,6 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
-#include "duckdb/common/serializer.hpp"
 #include "duckdb/storage/block.hpp"
 #include "duckdb/storage/block_manager.hpp"
 #include "duckdb/common/set.hpp"
@@ -23,8 +22,8 @@ struct MetadataBlock {
 	block_id_t block_id;
 	vector<uint8_t> free_blocks;
 
-	void Serialize(Serializer &serializer);
-	static MetadataBlock Deserialize(Deserializer &source);
+	void Write(WriteStream &sink);
+	static MetadataBlock Read(ReadStream &source);
 
 	idx_t FreeBlocksToInteger();
 	void FreeBlocksFromInteger(idx_t blocks);
@@ -68,8 +67,8 @@ public:
 
 	idx_t BlockCount();
 
-	void Serialize(Serializer &serializer);
-	void Deserialize(Deserializer &source);
+	void Write(WriteStream &sink);
+	void Read(ReadStream &source);
 
 protected:
 	BlockManager &block_manager;

package/src/duckdb/src/include/duckdb/storage/metadata/metadata_reader.hpp

@@ -9,12 +9,13 @@
 #pragma once
 
 #include "duckdb/storage/metadata/metadata_manager.hpp"
+#include "duckdb/common/serializer/read_stream.hpp"
 
 namespace duckdb {
 
 enum class BlockReaderType { EXISTING_BLOCKS, REGISTER_BLOCKS };
 
-class MetadataReader : public Deserializer {
+class MetadataReader : public ReadStream {
 public:
 	MetadataReader(MetadataManager &manager, MetaBlockPointer pointer,
 	               BlockReaderType type = BlockReaderType::EXISTING_BLOCKS);

package/src/duckdb/src/include/duckdb/storage/metadata/metadata_writer.hpp

@@ -9,10 +9,11 @@
 #pragma once
 
 #include "duckdb/storage/metadata/metadata_manager.hpp"
+#include "duckdb/common/serializer/write_stream.hpp"
 
 namespace duckdb {
 
-class MetadataWriter : public Serializer {
+class MetadataWriter : public WriteStream {
 public:
 	MetadataWriter(const MetadataWriter &) = delete;
 	MetadataWriter &operator=(const MetadataWriter &) = delete;
@@ -22,7 +23,6 @@ public:
 
 public:
 	void WriteData(const_data_ptr_t buffer, idx_t write_size) override;
-
 	void Flush();
 
 	BlockPointer GetBlockPointer();

package/src/duckdb/src/include/duckdb/storage/partial_block_manager.hpp

@@ -25,30 +25,46 @@ class TableCatalogEntry;
 class ViewCatalogEntry;
 class TypeCatalogEntry;
 
+//! Regions that require zero-initialization to avoid leaking memory
+struct UninitializedRegion {
+	idx_t start;
+	idx_t end;
+};
+
+//! The current state of a partial block
 struct PartialBlockState {
+	//! The block id of the partial block
 	block_id_t block_id;
-	//! How big is the block we're writing to. (Total bytes to assign).
+	//! The total bytes that we can assign to this block
 	uint32_t block_size;
-	//! How many bytes of the allocation are used. (offset_in_block of next allocation)
-	uint32_t offset_in_block;
-	//! How many times has the block been used?
+	//! Next allocation offset, and also the current allocation size
+	uint32_t offset;
+	//! The number of times that this block has been used for partial allocations
 	uint32_t block_use_count;
 };
 
 struct PartialBlock {
-	explicit PartialBlock(PartialBlockState state) : state(std::move(state)) {
-	}
+	PartialBlock(PartialBlockState state, BlockManager &block_manager, const shared_ptr<BlockHandle> &block_handle);
 	virtual ~PartialBlock() {
 	}
 
+	//! The current state of a partial block
 	PartialBlockState state;
+	//! All uninitialized regions on this block, we need to zero-initialize them when flushing
+	vector<UninitializedRegion> uninitialized_regions;
+	//! The block manager of the partial block manager
+	BlockManager &block_manager;
+	//! The block handle of the underlying block that this partial block writes to
+	shared_ptr<BlockHandle> block_handle;
 
 public:
-	virtual void AddUninitializedRegion(idx_t start, idx_t end) = 0;
-	virtual void Flush(idx_t free_space_left) = 0;
-	virtual void Clear() {
-	}
-	virtual void Merge(PartialBlock &other, idx_t offset, idx_t other_size);
+	//! Add regions that need zero-initialization to avoid leaking memory
+	void AddUninitializedRegion(const idx_t start, const idx_t end);
+	//! Flush the block to disk and zero-initialize any free space and uninitialized regions
+	virtual void Flush(const idx_t free_space_left) = 0;
+	void FlushInternal(const idx_t free_space_left);
+	virtual void Merge(PartialBlock &other, idx_t offset, idx_t other_size) = 0;
+	virtual void Clear() = 0;
 
 public:
 	template <class TARGET>
@@ -59,13 +75,13 @@ public:
 };
 
 struct PartialBlockAllocation {
-	// BlockManager owning the block_id
+	//! The BlockManager owning the block_id
 	BlockManager *block_manager {nullptr};
-	//! How many bytes assigned to the caller?
+	//! The number of assigned bytes to the caller
 	uint32_t allocation_size;
-	//! State of assigned block.
+	//! The current state of the partial block
 	PartialBlockState state;
-	//! Arbitrary state related to partial block storage.
+	//! Arbitrary state related to the partial block storage
 	unique_ptr<PartialBlock> partial_block;
 };
 
@@ -76,12 +92,12 @@ enum class CheckpointType { FULL_CHECKPOINT, APPEND_TO_TABLE };
 //! In any case, they must share a block manager.
 class PartialBlockManager {
 public:
-	// 20% free / 80% utilization
+	//! 20% free / 80% utilization
 	static constexpr const idx_t DEFAULT_MAX_PARTIAL_BLOCK_SIZE = Storage::BLOCK_SIZE / 5 * 4;
-	// Max number of shared references to a block. No effective limit by default.
+	//! Max number of shared references to a block. No effective limit by default.
 	static constexpr const idx_t DEFAULT_MAX_USE_COUNT = 1u << 20;
-	// No point letting map size grow unbounded. We'll drop blocks with the
-	// least free space first.
+	//! No point letting map size grow unbounded. We'll drop blocks with the
+	//! least free space first.
 	static constexpr const idx_t MAX_BLOCK_MAP_SIZE = 1u << 31;
 
 public:

package/src/duckdb/src/include/duckdb/storage/statistics/base_statistics.hpp

@@ -19,13 +19,9 @@
 namespace duckdb {
 struct SelectionVector;
 
-class FormatSerializer;
-class FormatDeserializer;
-
 class Serializer;
 class Deserializer;
-class FieldWriter;
-class FieldReader;
+
 class Vector;
 struct UnifiedVectorFormat;
 
@@ -96,11 +92,7 @@ public:
 	void CopyBase(const BaseStatistics &orig);
 
 	void Serialize(Serializer &serializer) const;
-	void Serialize(FieldWriter &writer) const;
-	static BaseStatistics Deserialize(Deserializer &source, LogicalType type);
-
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static BaseStatistics FormatDeserialize(FormatDeserializer &deserializer);
+	static BaseStatistics Deserialize(Deserializer &deserializer);
 
 	//! Verify that a vector does not violate the statistics
 	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const;
@@ -122,7 +114,6 @@ private:
 
 	static BaseStatistics CreateUnknownType(LogicalType type);
 	static BaseStatistics CreateEmptyType(LogicalType type);
-	static BaseStatistics DeserializeType(FieldReader &reader, LogicalType type);
 	static BaseStatistics FromConstantType(const Value &input);
 
 private:

package/src/duckdb/src/include/duckdb/storage/statistics/column_statistics.hpp

@@ -12,7 +12,7 @@
 #include "duckdb/storage/statistics/distinct_statistics.hpp"
 
 namespace duckdb {
-class FormatSerializer;
+class Serializer;
 
 class ColumnStatistics {
 public:
@@ -33,11 +33,9 @@ public:
 	void SetDistinct(unique_ptr<DistinctStatistics> distinct_stats);
 
 	shared_ptr<ColumnStatistics> Copy() const;
-	void Serialize(Serializer &serializer) const;
-	static shared_ptr<ColumnStatistics> Deserialize(Deserializer &source, const LogicalType &type);
 
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static shared_ptr<ColumnStatistics> FormatDeserialize(FormatDeserializer &source);
+	void Serialize(Serializer &serializer) const;
+	static shared_ptr<ColumnStatistics> Deserialize(Deserializer &source);
 
 private:
 	BaseStatistics stats;

package/src/duckdb/src/include/duckdb/storage/statistics/distinct_statistics.hpp

@@ -13,11 +13,9 @@
 #include "duckdb/storage/statistics/base_statistics.hpp"
 
 namespace duckdb {
+class Vector;
 class Serializer;
 class Deserializer;
-class Vector;
-class FormatSerializer;
-class FormatDeserializer;
 
 class DistinctStatistics {
 public:
@@ -36,12 +34,6 @@ public:
 
 	unique_ptr<DistinctStatistics> Copy() const;
 
-	void Serialize(Serializer &serializer) const;
-	void Serialize(FieldWriter &writer) const;
-
-	static unique_ptr<DistinctStatistics> Deserialize(Deserializer &source);
-	static unique_ptr<DistinctStatistics> Deserialize(FieldReader &reader);
-
 	void Update(Vector &update, idx_t count, bool sample = true);
 	void Update(UnifiedVectorFormat &update_data, const LogicalType &ptype, idx_t count, bool sample = true);
 
@@ -50,8 +42,8 @@ public:
 
 	static bool TypeIsSupported(const LogicalType &type);
 
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static unique_ptr<DistinctStatistics> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<DistinctStatistics> Deserialize(Deserializer &deserializer);
 
 private:
 	//! For distinct statistics we sample the input to speed up insertions

package/src/duckdb/src/include/duckdb/storage/statistics/list_stats.hpp

@@ -14,8 +14,6 @@
 
 namespace duckdb {
 class BaseStatistics;
-class FieldWriter;
-class FieldReader;
 struct SelectionVector;
 class Vector;
 
@@ -28,11 +26,8 @@ struct ListStats {
 	DUCKDB_API static BaseStatistics &GetChildStats(BaseStatistics &stats);
 	DUCKDB_API static void SetChildStats(BaseStatistics &stats, unique_ptr<BaseStatistics> new_stats);
 
-	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
-	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
-
-	DUCKDB_API static void FormatSerialize(const BaseStatistics &stats, FormatSerializer &serializer);
-	DUCKDB_API static BaseStatistics FormatDeserialize(FormatDeserializer &deserializer, LogicalType type);
+	DUCKDB_API static void Serialize(const BaseStatistics &stats, Serializer &serializer);
+	DUCKDB_API static void Deserialize(Deserializer &deserializer, BaseStatistics &base);
 
 	DUCKDB_API static string ToString(const BaseStatistics &stats);
 

package/src/duckdb/src/include/duckdb/storage/statistics/node_statistics.hpp

@@ -9,7 +9,6 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
-#include "duckdb/common/serializer.hpp"
 
 namespace duckdb {
 
@@ -24,31 +23,6 @@ public:
 	    : has_estimated_cardinality(true), estimated_cardinality(estimated_cardinality), has_max_cardinality(true),
 	      max_cardinality(max_cardinality) {
 	}
-	void Serialize(Serializer &serializer) const {
-		serializer.Write(has_estimated_cardinality);
-		if (has_estimated_cardinality) {
-			serializer.Write(estimated_cardinality);
-			serializer.Write(has_max_cardinality);
-			if (has_max_cardinality) {
-				serializer.Write(max_cardinality);
-			}
-		} else {
-			D_ASSERT(!has_max_cardinality);
-		}
-	}
-	static unique_ptr<NodeStatistics> Deserialize(Deserializer &source) {
-		bool has_estimated_cardinality = source.Read<bool>();
-		if (!has_estimated_cardinality) {
-			return make_uniq<NodeStatistics>();
-		}
-		idx_t estimated_cardinality = source.Read<idx_t>();
-		bool has_max_cardinality = source.Read<bool>();
-		if (!has_max_cardinality) {
-			return make_uniq<NodeStatistics>(estimated_cardinality);
-		}
-		idx_t max_cardinality = source.Read<idx_t>();
-		return make_uniq<NodeStatistics>(estimated_cardinality, max_cardinality);
-	}
 
 	//! Whether or not the node has an estimated cardinality specified
 	bool has_estimated_cardinality;