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

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

@@ -16,8 +16,6 @@
 
 namespace duckdb {
 class BaseStatistics;
-class FieldWriter;
-class FieldReader;
 struct SelectionVector;
 class Vector;
 
@@ -61,11 +59,8 @@ struct NumericStats {
 
 	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other_p);
 
-	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 &stats);
 
 	DUCKDB_API static string ToString(const BaseStatistics &stats);
 

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

@@ -17,8 +17,6 @@
 
 namespace duckdb {
 class BaseStatistics;
-class FieldWriter;
-class FieldReader;
 struct SelectionVector;
 class Vector;
 
@@ -58,11 +56,8 @@ struct StringStats {
 	//! FIXME: make this part of Set on statistics
 	DUCKDB_API static void SetContainsUnicode(BaseStatistics &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/struct_stats.hpp

@@ -13,8 +13,6 @@
 
 namespace duckdb {
 class BaseStatistics;
-class FieldWriter;
-class FieldReader;
 struct SelectionVector;
 class Vector;
 
@@ -29,11 +27,8 @@ struct StructStats {
 	DUCKDB_API static void SetChildStats(BaseStatistics &stats, idx_t i, const BaseStatistics &new_stats);
 	DUCKDB_API static void SetChildStats(BaseStatistics &stats, idx_t i, 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/storage_info.hpp

@@ -12,8 +12,6 @@
 #include "duckdb/common/vector_size.hpp"
 
 namespace duckdb {
-class Serializer;
-class Deserializer;
 struct FileHandle;
 
 #define STANDARD_ROW_GROUPS_SIZE 122880
@@ -53,8 +51,8 @@ struct MainHeader {
 
 	static void CheckMagicBytes(FileHandle &handle);
 
-	void Serialize(Serializer &ser);
-	static MainHeader Deserialize(Deserializer &source);
+	void Write(WriteStream &ser);
+	static MainHeader Read(ReadStream &source);
 };
 
 //! The DatabaseHeader contains information about the current state of the database. Every storage file has two
@@ -72,8 +70,8 @@ struct DatabaseHeader {
 	//! block_count any blocks appearing AFTER block_count are implicitly part of the free_list.
 	uint64_t block_count;
 
-	void Serialize(Serializer &ser);
-	static DatabaseHeader Deserialize(Deserializer &source);
+	void Write(WriteStream &ser);
+	static DatabaseHeader Read(ReadStream &source);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/chunk_info.hpp

@@ -18,8 +18,8 @@ struct SelectionVector;
 class Transaction;
 struct TransactionData;
 
-class FormatSerializer;
-class FormatDeserializer;
+class Serializer;
+class Deserializer;
 
 enum class ChunkInfoType : uint8_t { CONSTANT_INFO, VECTOR_INFO, EMPTY_INFO };
 
@@ -46,11 +46,8 @@ public:
 	virtual void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) = 0;
 	virtual idx_t GetCommittedDeletedCount(idx_t max_count) = 0;
 
-	virtual void Serialize(Serializer &serialize) = 0;
-	static unique_ptr<ChunkInfo> Deserialize(Deserializer &source);
-
-	virtual void FormatSerialize(FormatSerializer &serializer) const = 0;
-	static unique_ptr<ChunkInfo> FormatDeserialize(FormatDeserializer &deserializer);
+	virtual void Serialize(Serializer &serializer) const = 0;
+	static unique_ptr<ChunkInfo> Deserialize(Deserializer &deserializer);
 
 public:
 	template <class TARGET>
@@ -88,11 +85,8 @@ public:
 	void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) override;
 	idx_t GetCommittedDeletedCount(idx_t max_count) override;
 
-	void Serialize(Serializer &serialize) override;
-	static unique_ptr<ChunkInfo> Deserialize(Deserializer &source);
-
-	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ChunkInfo> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<ChunkInfo> Deserialize(Deserializer &deserializer);
 
 private:
 	template <class OP>
@@ -136,11 +130,8 @@ public:
 	idx_t Delete(transaction_t transaction_id, row_t rows[], idx_t count);
 	void CommitDelete(transaction_t commit_id, row_t rows[], idx_t count);
 
-	void Serialize(Serializer &serialize) override;
-	static unique_ptr<ChunkInfo> Deserialize(Deserializer &source);
-
-	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ChunkInfo> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<ChunkInfo> Deserialize(Deserializer &deserializer);
 
 private:
 	template <class OP>

package/src/duckdb/src/include/duckdb/storage/table/column_checkpoint_state.hpp

@@ -41,7 +41,7 @@ public:
 	virtual unique_ptr<BaseStatistics> GetStatistics();
 
 	virtual void FlushSegment(unique_ptr<ColumnSegment> segment, idx_t segment_size);
-	virtual void WriteDataPointers(RowGroupWriter &writer);
+	virtual void WriteDataPointers(RowGroupWriter &writer, Serializer &serializer);
 
 public:
 	template <class TARGET>
@@ -68,37 +68,22 @@ struct PartialBlockForCheckpoint : public PartialBlock {
 	};
 
 public:
-	PartialBlockForCheckpoint(ColumnData &data, ColumnSegment &segment, BlockManager &block_manager,
-	                          PartialBlockState state);
+	PartialBlockForCheckpoint(ColumnData &data, ColumnSegment &segment, PartialBlockState state,
+	                          BlockManager &block_manager);
 	~PartialBlockForCheckpoint() override;
 
 	// We will copy all segment data into the memory of the shared block.
 	// Once the block is full (or checkpoint is complete) we'll invoke Flush().
 	// This will cause the block to get written to storage (via BlockManger::ConvertToPersistent),
 	// and all segments to have their references updated (via ColumnSegment::ConvertToPersistent)
-	BlockManager &block_manager;
-	shared_ptr<BlockHandle> block;
 	vector<PartialColumnSegment> segments;
 
-private:
-	struct UninitializedRegion {
-		idx_t start;
-		idx_t end;
-	};
-	vector<UninitializedRegion> uninitialized_regions;
-
 public:
 	bool IsFlushed();
-
-	void AddUninitializedRegion(idx_t start, idx_t end) override;
-
-	void Flush(idx_t free_space_left) override;
-
-	void Clear() override;
-
+	void Flush(const idx_t free_space_left) override;
 	void Merge(PartialBlock &other, idx_t offset, idx_t other_size) override;
-
 	void AddSegmentToTail(ColumnData &data, ColumnSegment &segment, uint32_t offset_in_block);
+	void Clear() override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/column_data.hpp

@@ -125,9 +125,9 @@ public:
 	virtual void CheckpointScan(ColumnSegment &segment, ColumnScanState &state, idx_t row_group_start, idx_t count,
 	                            Vector &scan_vector);
 
-	virtual void DeserializeColumn(Deserializer &source);
+	virtual void DeserializeColumn(Deserializer &deserializer);
 	static shared_ptr<ColumnData> Deserialize(BlockManager &block_manager, DataTableInfo &info, idx_t column_index,
-	                                          idx_t start_row, Deserializer &source, const LogicalType &type,
+	                                          idx_t start_row, ReadStream &source, const LogicalType &type,
 	                                          optional_ptr<ColumnData> parent);
 
 	virtual void GetColumnSegmentInfo(idx_t row_group_index, vector<idx_t> col_path, vector<ColumnSegmentInfo> &result);

package/src/duckdb/src/include/duckdb/storage/table/list_column_data.hpp

@@ -56,7 +56,7 @@ public:
 	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, PartialBlockManager &partial_block_manager,
 	                                             ColumnCheckpointInfo &checkpoint_info) override;
 
-	void DeserializeColumn(Deserializer &source) override;
+	void DeserializeColumn(Deserializer &deserializer) override;
 
 	void GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
 	                          vector<duckdb::ColumnSegmentInfo> &result) override;

package/src/duckdb/src/include/duckdb/storage/table/row_group.hpp

@@ -124,8 +124,6 @@ public:
 	RowGroupWriteData WriteToDisk(PartialBlockManager &manager, const vector<CompressionType> &compression_types);
 	bool AllDeleted();
 	RowGroupPointer Checkpoint(RowGroupWriter &writer, TableStatistics &global_stats);
-	static void Serialize(RowGroupPointer &pointer, Serializer &serializer);
-	static RowGroupPointer Deserialize(Deserializer &source, const vector<LogicalType> &columns);
 
 	void InitializeAppend(RowGroupAppendState &append_state);
 	void Append(RowGroupAppendState &append_state, DataChunk &chunk, idx_t append_count);
@@ -148,8 +146,8 @@ public:
 	void NextVector(CollectionScanState &state);
 
 	// Serialization
-	static void FormatSerialize(RowGroupPointer &pointer, FormatSerializer &serializer);
-	static RowGroupPointer FormatDeserialize(FormatDeserializer &deserializer);
+	static void Serialize(RowGroupPointer &pointer, Serializer &serializer);
+	static RowGroupPointer Deserialize(Deserializer &deserializer);
 
 private:
 	ChunkInfo *GetChunkInfo(idx_t vector_idx);
@@ -160,9 +158,6 @@ private:
 	template <TableScanType TYPE>
 	void TemplatedScan(TransactionData transaction, CollectionScanState &state, DataChunk &result);
 
-	static void CheckpointDeletes(VersionNode *versions, Serializer &serializer);
-	static shared_ptr<VersionNode> DeserializeDeletes(Deserializer &source);
-
 private:
 	mutex row_group_lock;
 	mutex stats_lock;

package/src/duckdb/src/include/duckdb/storage/table/standard_column_data.hpp

@@ -54,11 +54,11 @@ public:
 	void CheckpointScan(ColumnSegment &segment, ColumnScanState &state, idx_t row_group_start, idx_t count,
 	                    Vector &scan_vector) override;
 
-	void DeserializeColumn(Deserializer &source) override;
-
 	void GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
 	                          vector<duckdb::ColumnSegmentInfo> &result) override;
 
+	void DeserializeColumn(Deserializer &deserializer) override;
+
 	void Verify(RowGroup &parent) override;
 };
 

package/src/duckdb/src/include/duckdb/storage/table/table_statistics.hpp

@@ -16,8 +16,8 @@
 namespace duckdb {
 class ColumnList;
 class PersistentTableData;
-class FormatSerializer;
-class FormatDeserializer;
+class Serializer;
+class Deserializer;
 
 class TableStatisticsLock {
 public:
@@ -49,11 +49,8 @@ public:
 
 	unique_ptr<TableStatisticsLock> GetLock();
 
-	void Serialize(Serializer &serializer);
-	void Deserialize(Deserializer &source, ColumnList &columns);
-
-	void FormatSerialize(FormatSerializer &serializer);
-	void FormatDeserialize(FormatDeserializer &deserializer, ColumnList &columns);
+	void Serialize(Serializer &serializer) const;
+	void Deserialize(Deserializer &deserializer, ColumnList &columns);
 
 private:
 	//! The statistics lock

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

@@ -24,7 +24,6 @@ namespace duckdb {
 struct AlterInfo;
 
 class AttachedDatabase;
-class BufferedSerializer;
 class Catalog;
 class DatabaseInstance;
 class SchemaCatalogEntry;
@@ -38,53 +37,52 @@ class TransactionManager;
 
 class ReplayState {
 public:
-	ReplayState(AttachedDatabase &db, ClientContext &context, Deserializer &source)
-	    : db(db), context(context), catalog(db.GetCatalog()), source(source), deserialize_only(false) {
+	ReplayState(AttachedDatabase &db, ClientContext &context)
+	    : db(db), context(context), catalog(db.GetCatalog()), deserialize_only(false) {
 	}
 
 	AttachedDatabase &db;
 	ClientContext &context;
 	Catalog &catalog;
-	Deserializer &source;
 	optional_ptr<TableCatalogEntry> current_table;
 	bool deserialize_only;
 	MetaBlockPointer checkpoint_id;
 
 public:
-	void ReplayEntry(WALType entry_type);
+	void ReplayEntry(WALType entry_type, BinaryDeserializer &deserializer);
 
 protected:
-	virtual void ReplayCreateTable();
-	void ReplayDropTable();
-	void ReplayAlter();
+	virtual void ReplayCreateTable(BinaryDeserializer &deserializer);
+	void ReplayDropTable(BinaryDeserializer &deserializer);
+	void ReplayAlter(BinaryDeserializer &deserializer);
 
-	void ReplayCreateView();
-	void ReplayDropView();
+	void ReplayCreateView(BinaryDeserializer &deserializer);
+	void ReplayDropView(BinaryDeserializer &deserializer);
 
-	void ReplayCreateSchema();
-	void ReplayDropSchema();
+	void ReplayCreateSchema(BinaryDeserializer &deserializer);
+	void ReplayDropSchema(BinaryDeserializer &deserializer);
 
-	void ReplayCreateType();
-	void ReplayDropType();
+	void ReplayCreateType(BinaryDeserializer &deserializer);
+	void ReplayDropType(BinaryDeserializer &deserializer);
 
-	void ReplayCreateSequence();
-	void ReplayDropSequence();
-	void ReplaySequenceValue();
+	void ReplayCreateSequence(BinaryDeserializer &deserializer);
+	void ReplayDropSequence(BinaryDeserializer &deserializer);
+	void ReplaySequenceValue(BinaryDeserializer &deserializer);
 
-	void ReplayCreateMacro();
-	void ReplayDropMacro();
+	void ReplayCreateMacro(BinaryDeserializer &deserializer);
+	void ReplayDropMacro(BinaryDeserializer &deserializer);
 
-	void ReplayCreateTableMacro();
-	void ReplayDropTableMacro();
+	void ReplayCreateTableMacro(BinaryDeserializer &deserializer);
+	void ReplayDropTableMacro(BinaryDeserializer &deserializer);
 
-	void ReplayCreateIndex();
-	void ReplayDropIndex();
+	void ReplayCreateIndex(BinaryDeserializer &deserializer);
+	void ReplayDropIndex(BinaryDeserializer &deserializer);
 
-	void ReplayUseTable();
-	void ReplayInsert();
-	void ReplayDelete();
-	void ReplayUpdate();
-	void ReplayCheckpoint();
+	void ReplayUseTable(BinaryDeserializer &deserializer);
+	void ReplayInsert(BinaryDeserializer &deserializer);
+	void ReplayDelete(BinaryDeserializer &deserializer);
+	void ReplayUpdate(BinaryDeserializer &deserializer);
+	void ReplayCheckpoint(BinaryDeserializer &deserializer);
 };
 
 //! The WriteAheadLog (WAL) is a log that is used to provide durability. Prior
@@ -136,7 +134,7 @@ public:
 	//! Sets the table used for subsequent insert/delete/update commands
 	void WriteSetTable(string &schema, string &table);
 
-	void WriteAlter(data_ptr_t ptr, idx_t data_size);
+	void WriteAlter(const AlterInfo &info);
 
 	void WriteInsert(DataChunk &chunk);
 	void WriteDelete(DataChunk &chunk);

package/src/duckdb/src/include/duckdb/verification/statement_verifier.hpp

@@ -18,8 +18,6 @@ enum class VerificationType : uint8_t {
 	ORIGINAL,
 	COPIED,
 	DESERIALIZED,
-	DESERIALIZED_V2,
-	DESERIALIZED_V2_NO_DEFAULT,
 	PARSED,
 	UNOPTIMIZED,
 	NO_OPERATOR_CACHING,

package/src/duckdb/src/main/client_context.cpp

@@ -7,9 +7,7 @@
 #include "duckdb/common/http_state.hpp"
 #include "duckdb/common/preserved_error.hpp"
 #include "duckdb/common/progress_bar/progress_bar.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
 #include "duckdb/common/serializer/buffered_file_writer.hpp"
-#include "duckdb/common/serializer/buffered_serializer.hpp"
 #include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/execution/column_binding_resolver.hpp"
 #include "duckdb/execution/operator/helper/physical_result_collector.hpp"
@@ -27,11 +25,9 @@
 #include "duckdb/main/relation.hpp"
 #include "duckdb/main/stream_query_result.hpp"
 #include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/parameter_expression.hpp"
 #include "duckdb/parser/parsed_data/create_function_info.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/statement/drop_statement.hpp"
@@ -43,9 +39,7 @@
 #include "duckdb/planner/operator/logical_execute.hpp"
 #include "duckdb/planner/planner.hpp"
 #include "duckdb/planner/pragma_handler.hpp"
-#include "duckdb/storage/data_table.hpp"
 #include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/transaction/transaction.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
 
 namespace duckdb {

package/src/duckdb/src/main/client_verify.cpp

@@ -40,8 +40,6 @@ PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string
 	if (config.query_verification_enabled) {
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::COPIED, stmt));
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::DESERIALIZED, stmt));
-		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::DESERIALIZED_V2, stmt));
-		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::DESERIALIZED_V2_NO_DEFAULT, stmt));
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::UNOPTIMIZED, stmt));
 		prepared_statement_verifier = StatementVerifier::Create(VerificationType::PREPARED, stmt);
 #ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE

package/src/duckdb/src/main/extension/extension_helper.cpp

@@ -118,6 +118,7 @@ static DefaultExtension internal_extensions[] = {
     {"spatial", "Geospatial extension that adds support for working with spatial data and functions", false},
     {"substrait", "Adds support for the Substrait integration", false},
     {"aws", "Provides features that depend on the AWS SDK", false},
+    {"arrow", "A zero-copy data integration between Apache Arrow and DuckDB", false},
     {"azure", "Adds a filesystem abstraction for Azure blob storage to DuckDB", false},
     {"iceberg", "Adds support for Apache Iceberg", false},
     {"visualizer", "Creates an HTML-based visualization of the query plan", false},

package/src/duckdb/src/main/relation.cpp

@@ -47,6 +47,11 @@ shared_ptr<Relation> Relation::Project(const vector<string> &expressions) {
 	return Project(expressions, aliases);
 }
 
+shared_ptr<Relation> Relation::Project(vector<unique_ptr<ParsedExpression>> expressions,
+                                       const vector<string> &aliases) {
+	return make_shared<ProjectionRelation>(shared_from_this(), std::move(expressions), aliases);
+}
+
 static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(ClientContext &context,
                                                                        const vector<string> &expressions) {
 	if (expressions.empty()) {
@@ -73,7 +78,11 @@ shared_ptr<Relation> Relation::Filter(const string &expression) {
 	if (expression_list.size() != 1) {
 		throw ParserException("Expected a single expression as filter condition");
 	}
-	return make_shared<FilterRelation>(shared_from_this(), std::move(expression_list[0]));
+	return Filter(std::move(expression_list[0]));
+}
+
+shared_ptr<Relation> Relation::Filter(unique_ptr<ParsedExpression> expression) {
+	return make_shared<FilterRelation>(shared_from_this(), std::move(expression));
 }
 
 shared_ptr<Relation> Relation::Filter(const vector<string> &expressions) {
@@ -95,6 +104,10 @@ shared_ptr<Relation> Relation::Limit(int64_t limit, int64_t offset) {
 
 shared_ptr<Relation> Relation::Order(const string &expression) {
 	auto order_list = Parser::ParseOrderList(expression, context.GetContext()->GetParserOptions());
+	return Order(std::move(order_list));
+}
+
+shared_ptr<Relation> Relation::Order(vector<OrderByNode> order_list) {
 	return make_shared<OrderRelation>(shared_from_this(), std::move(order_list));
 }
 
@@ -110,7 +123,7 @@ shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
 		}
 		order_list.push_back(std::move(inner_list[0]));
 	}
-	return make_shared<OrderRelation>(shared_from_this(), std::move(order_list));
+	return Order(std::move(order_list));
 }
 
 shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const string &condition, JoinType type,

package/src/duckdb/src/parser/column_definition.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/parser/column_definition.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
@@ -26,30 +25,6 @@ ColumnDefinition ColumnDefinition::Copy() const {
 	return copy;
 }
 
-void ColumnDefinition::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteSerializable(type);
-	writer.WriteOptional(expression);
-	writer.WriteField<TableColumnType>(category);
-	writer.WriteField<duckdb::CompressionType>(compression_type);
-	writer.Finalize();
-}
-
-ColumnDefinition ColumnDefinition::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto column_name = reader.ReadRequired<string>();
-	auto column_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto expression = reader.ReadOptional<ParsedExpression>(nullptr);
-	auto category = reader.ReadField<TableColumnType>(TableColumnType::STANDARD);
-	auto compression_type = reader.ReadField<duckdb::CompressionType>(duckdb::CompressionType::COMPRESSION_AUTO);
-	reader.Finalize();
-
-	ColumnDefinition result(column_name, column_type, std::move(expression), category);
-	result.compression_type = compression_type;
-	return result;
-}
-
 const unique_ptr<ParsedExpression> &ColumnDefinition::DefaultValue() const {
 	if (Generated()) {
 		throw InternalException("Calling DefaultValue() on a generated column");

package/src/duckdb/src/parser/column_list.cpp

@@ -158,19 +158,6 @@ ColumnList ColumnList::Copy() const {
 	return result;
 }
 
-void ColumnList::Serialize(FieldWriter &writer) const {
-	writer.WriteRegularSerializableList(columns);
-}
-
-ColumnList ColumnList::Deserialize(FieldReader &reader) {
-	ColumnList result;
-	auto columns = reader.ReadRequiredSerializableList<ColumnDefinition, ColumnDefinition>();
-	for (auto &col : columns) {
-		result.AddColumn(std::move(col));
-	}
-	return result;
-}
-
 ColumnList::ColumnListIterator ColumnList::Logical() const {
 	return ColumnListIterator(*this, false);
 }

package/src/duckdb/src/parser/constraint.cpp

@@ -1,9 +1,7 @@
 #include "duckdb/parser/constraint.hpp"
 
 #include "duckdb/common/printer.hpp"
-#include "duckdb/common/serializer.hpp"
 #include "duckdb/parser/constraints/list.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -13,37 +11,6 @@ Constraint::Constraint(ConstraintType type) : type(type) {
 Constraint::~Constraint() {
 }
 
-void Constraint::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<ConstraintType>(type);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<Constraint> Constraint::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto type = reader.ReadRequired<ConstraintType>();
-	unique_ptr<Constraint> result;
-	switch (type) {
-	case ConstraintType::NOT_NULL:
-		result = NotNullConstraint::Deserialize(reader);
-		break;
-	case ConstraintType::CHECK:
-		result = CheckConstraint::Deserialize(reader);
-		break;
-	case ConstraintType::UNIQUE:
-		result = UniqueConstraint::Deserialize(reader);
-		break;
-	case ConstraintType::FOREIGN_KEY:
-		result = ForeignKeyConstraint::Deserialize(reader);
-		break;
-	default:
-		throw InternalException("Unrecognized constraint type for serialization");
-	}
-	reader.Finalize();
-	return result;
-}
-
 void Constraint::Print() const {
 	Printer::Print(ToString());
 }

package/src/duckdb/src/parser/constraints/check_constraint.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/parser/constraints/check_constraint.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 CheckConstraint::CheckConstraint(unique_ptr<ParsedExpression> expression)
@@ -16,13 +14,4 @@ unique_ptr<Constraint> CheckConstraint::Copy() const {
 	return make_uniq<CheckConstraint>(expression->Copy());
 }
 
-void CheckConstraint::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*expression);
-}
-
-unique_ptr<Constraint> CheckConstraint::Deserialize(FieldReader &source) {
-	auto expression = source.ReadRequiredSerializable<ParsedExpression>();
-	return make_uniq<CheckConstraint>(std::move(expression));
-}
-
 } // namespace duckdb