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

package/src/duckdb/src/parser/expression/parameter_expression.cpp

@@ -1,12 +1,11 @@
 #include "duckdb/parser/expression/parameter_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/to_string.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 {
 
@@ -34,14 +33,4 @@ hash_t ParameterExpression::Hash() const {
 	return CombineHash(duckdb::Hash(identifier.c_str(), identifier.size()), result);
 }
 
-void ParameterExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteString(identifier);
-}
-
-unique_ptr<ParsedExpression> ParameterExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto expression = make_uniq<ParameterExpression>();
-	expression->identifier = reader.ReadRequired<string>();
-	return std::move(expression);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/positional_reference_expression.cpp

@@ -1,12 +1,11 @@
 #include "duckdb/parser/expression/positional_reference_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/to_string.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 {
 
@@ -38,13 +37,4 @@ hash_t PositionalReferenceExpression::Hash() const {
 	return CombineHash(duckdb::Hash(index), result);
 }
 
-void PositionalReferenceExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteField<idx_t>(index);
-}
-
-unique_ptr<ParsedExpression> PositionalReferenceExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto expression = make_uniq<PositionalReferenceExpression>(reader.ReadRequired<idx_t>());
-	return std::move(expression);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/star_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/star_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.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 {
 
@@ -79,46 +78,6 @@ bool StarExpression::Equal(const StarExpression &a, const StarExpression &b) {
 	return true;
 }
 
-void StarExpression::Serialize(FieldWriter &writer) const {
-	auto &serializer = writer.GetSerializer();
-
-	writer.WriteString(relation_name);
-
-	// in order to write the exclude_list/replace_list as single fields we directly use the field writers' internal
-	// serializer
-	writer.WriteField<uint32_t>(exclude_list.size());
-	for (auto &exclusion : exclude_list) {
-		serializer.WriteString(exclusion);
-	}
-	writer.WriteField<uint32_t>(replace_list.size());
-	for (auto &entry : replace_list) {
-		serializer.WriteString(entry.first);
-		entry.second->Serialize(serializer);
-	}
-	writer.WriteField<bool>(columns);
-	writer.WriteOptional(expr);
-}
-
-unique_ptr<ParsedExpression> StarExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto &source = reader.GetSource();
-
-	auto result = make_uniq<StarExpression>();
-	result->relation_name = reader.ReadRequired<string>();
-	auto exclusion_count = reader.ReadRequired<uint32_t>();
-	for (idx_t i = 0; i < exclusion_count; i++) {
-		result->exclude_list.insert(source.Read<string>());
-	}
-	auto replace_count = reader.ReadRequired<uint32_t>();
-	for (idx_t i = 0; i < replace_count; i++) {
-		auto name = source.Read<string>();
-		auto expr = ParsedExpression::Deserialize(source);
-		result->replace_list.insert(make_pair(name, std::move(expr)));
-	}
-	result->columns = reader.ReadField<bool>(false);
-	result->expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	return std::move(result);
-}
-
 unique_ptr<ParsedExpression> StarExpression::Copy() const {
 	auto copy = make_uniq<StarExpression>(relation_name);
 	copy->exclude_list = exclude_list;

package/src/duckdb/src/parser/expression/subquery_expression.cpp

@@ -1,9 +1,8 @@
 #include "duckdb/parser/expression/subquery_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.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 {
 
@@ -49,29 +48,4 @@ unique_ptr<ParsedExpression> SubqueryExpression::Copy() const {
 	return std::move(copy);
 }
 
-void SubqueryExpression::Serialize(FieldWriter &writer) const {
-	auto &serializer = writer.GetSerializer();
-
-	writer.WriteField<SubqueryType>(subquery_type);
-	// FIXME: this shouldn't use a serializer (probably)?
-	subquery->Serialize(serializer);
-	writer.WriteOptional(child);
-	writer.WriteField<ExpressionType>(comparison_type);
-}
-
-unique_ptr<ParsedExpression> SubqueryExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	// FIXME: this shouldn't use a source
-	auto &source = reader.GetSource();
-
-	auto subquery_type = reader.ReadRequired<SubqueryType>();
-	auto subquery = SelectStatement::Deserialize(source);
-
-	auto expression = make_uniq<SubqueryExpression>();
-	expression->subquery_type = subquery_type;
-	expression->subquery = std::move(subquery);
-	expression->child = reader.ReadOptional<ParsedExpression>(nullptr);
-	expression->comparison_type = reader.ReadRequired<ExpressionType>();
-	return std::move(expression);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/window_expression.cpp

@@ -1,12 +1,11 @@
 #include "duckdb/parser/expression/window_expression.hpp"
 
 #include "duckdb/common/limits.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 
 #include "duckdb/common/enum_util.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 {
 
@@ -137,54 +136,4 @@ unique_ptr<ParsedExpression> WindowExpression::Copy() const {
 	return std::move(new_window);
 }
 
-void WindowExpression::Serialize(FieldWriter &writer) const {
-	auto &serializer = writer.GetSerializer();
-
-	writer.WriteString(function_name);
-	writer.WriteString(schema);
-	writer.WriteSerializableList(children);
-	writer.WriteSerializableList(partitions);
-	// FIXME: should not use serializer here (probably)?
-	D_ASSERT(orders.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteField<uint32_t>((uint32_t)orders.size());
-	for (auto &order : orders) {
-		order.Serialize(serializer);
-	}
-	writer.WriteField<WindowBoundary>(start);
-	writer.WriteField<WindowBoundary>(end);
-
-	writer.WriteOptional(start_expr);
-	writer.WriteOptional(end_expr);
-	writer.WriteOptional(offset_expr);
-	writer.WriteOptional(default_expr);
-	writer.WriteField<bool>(ignore_nulls);
-	writer.WriteOptional(filter_expr);
-	writer.WriteString(catalog);
-}
-
-unique_ptr<ParsedExpression> WindowExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto function_name = reader.ReadRequired<string>();
-	auto schema = reader.ReadRequired<string>();
-	auto expr = make_uniq<WindowExpression>(type, INVALID_CATALOG, std::move(schema), function_name);
-	expr->children = reader.ReadRequiredSerializableList<ParsedExpression>();
-	expr->partitions = reader.ReadRequiredSerializableList<ParsedExpression>();
-
-	auto order_count = reader.ReadRequired<uint32_t>();
-	auto &source = reader.GetSource();
-	for (idx_t i = 0; i < order_count; i++) {
-		expr->orders.push_back(OrderByNode::Deserialize(source));
-	}
-	expr->start = reader.ReadRequired<WindowBoundary>();
-	expr->end = reader.ReadRequired<WindowBoundary>();
-
-	expr->start_expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	expr->end_expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	expr->offset_expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	expr->default_expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	expr->ignore_nulls = reader.ReadRequired<bool>();
-	expr->filter_expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	expr->catalog = reader.ReadField<string>(INVALID_CATALOG);
-	return std::move(expr);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/alter_info.cpp

@@ -3,8 +3,6 @@
 #include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp"
 #include "duckdb/parser/parsed_data/alter_table_function_info.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 AlterInfo::AlterInfo(AlterType type, string catalog_p, string schema_p, string name_p, OnEntryNotFound if_not_found)
@@ -18,39 +16,6 @@ AlterInfo::AlterInfo(AlterType type) : ParseInfo(TYPE), type(type) {
 AlterInfo::~AlterInfo() {
 }
 
-void AlterInfo::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<AlterType>(type);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<AlterInfo> AlterInfo::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto type = reader.ReadRequired<AlterType>();
-
-	unique_ptr<AlterInfo> result;
-	switch (type) {
-	case AlterType::ALTER_TABLE:
-		result = AlterTableInfo::Deserialize(reader);
-		break;
-	case AlterType::ALTER_VIEW:
-		result = AlterViewInfo::Deserialize(reader);
-		break;
-	case AlterType::ALTER_SCALAR_FUNCTION:
-		result = AlterScalarFunctionInfo::Deserialize(reader);
-		break;
-	case AlterType::ALTER_TABLE_FUNCTION:
-		result = AlterTableFunctionInfo::Deserialize(reader);
-		break;
-	default:
-		throw SerializationException("Unknown alter type for deserialization!");
-	}
-	reader.Finalize();
-
-	return result;
-}
-
 AlterEntryData AlterInfo::GetAlterEntryData() const {
 	AlterEntryData data;
 	data.catalog = catalog;

package/src/duckdb/src/parser/parsed_data/alter_scalar_function_info.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/constraint.hpp"
 
 namespace duckdb {
@@ -20,23 +19,6 @@ CatalogType AlterScalarFunctionInfo::GetCatalogType() const {
 	return CatalogType::SCALAR_FUNCTION_ENTRY;
 }
 
-void AlterScalarFunctionInfo::Serialize(FieldWriter &writer) const {
-	writer.WriteField<AlterScalarFunctionType>(alter_scalar_function_type);
-	writer.WriteString(catalog);
-	writer.WriteString(schema);
-	writer.WriteString(name);
-	writer.WriteField(if_not_found);
-}
-
-unique_ptr<AlterInfo> AlterScalarFunctionInfo::Deserialize(FieldReader &reader) {
-	//	auto type = reader.ReadRequired<AlterScalarFunctionType>();
-	//	auto schema = reader.ReadRequired<string>();
-	//	auto table = reader.ReadRequired<string>();
-	//	auto if_exists = reader.ReadRequired<bool>();
-
-	throw NotImplementedException("AlterScalarFunctionInfo cannot be deserialized");
-}
-
 //===--------------------------------------------------------------------===//
 // AddScalarFunctionOverloadInfo
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/parser/parsed_data/alter_table_function_info.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/parser/parsed_data/alter_table_function_info.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/constraint.hpp"
 
 namespace duckdb {
@@ -20,18 +19,6 @@ CatalogType AlterTableFunctionInfo::GetCatalogType() const {
 	return CatalogType::TABLE_FUNCTION_ENTRY;
 }
 
-void AlterTableFunctionInfo::Serialize(FieldWriter &writer) const {
-	writer.WriteField<AlterTableFunctionType>(alter_table_function_type);
-	writer.WriteString(catalog);
-	writer.WriteString(schema);
-	writer.WriteString(name);
-	writer.WriteField(if_not_found);
-}
-
-unique_ptr<AlterInfo> AlterTableFunctionInfo::Deserialize(FieldReader &reader) {
-	throw NotImplementedException("AlterTableFunctionInfo cannot be deserialized");
-}
-
 //===--------------------------------------------------------------------===//
 // AddTableFunctionOverloadInfo
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/parser/parsed_data/alter_table_info.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/constraint.hpp"
 
 namespace duckdb {
@@ -26,10 +25,6 @@ unique_ptr<AlterInfo> ChangeOwnershipInfo::Copy() const {
 	                                                      owner_name, if_not_found);
 }
 
-void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
-	throw InternalException("ChangeOwnershipInfo cannot be serialized");
-}
-
 //===--------------------------------------------------------------------===//
 // AlterTableInfo
 //===--------------------------------------------------------------------===//
@@ -47,49 +42,6 @@ AlterTableInfo::~AlterTableInfo() {
 CatalogType AlterTableInfo::GetCatalogType() const {
 	return CatalogType::TABLE_ENTRY;
 }
-
-void AlterTableInfo::Serialize(FieldWriter &writer) const {
-	writer.WriteField<AlterTableType>(alter_table_type);
-	writer.WriteString(catalog);
-	writer.WriteString(schema);
-	writer.WriteString(name);
-	writer.WriteField(if_not_found);
-	SerializeAlterTable(writer);
-}
-
-unique_ptr<AlterInfo> AlterTableInfo::Deserialize(FieldReader &reader) {
-	auto type = reader.ReadRequired<AlterTableType>();
-	AlterEntryData data;
-	data.catalog = reader.ReadRequired<string>();
-	data.schema = reader.ReadRequired<string>();
-	data.name = reader.ReadRequired<string>();
-	data.if_not_found = reader.ReadRequired<OnEntryNotFound>();
-
-	unique_ptr<AlterTableInfo> info;
-	switch (type) {
-	case AlterTableType::RENAME_COLUMN:
-		return RenameColumnInfo::Deserialize(reader, std::move(data));
-	case AlterTableType::RENAME_TABLE:
-		return RenameTableInfo::Deserialize(reader, std::move(data));
-	case AlterTableType::ADD_COLUMN:
-		return AddColumnInfo::Deserialize(reader, std::move(data));
-	case AlterTableType::REMOVE_COLUMN:
-		return RemoveColumnInfo::Deserialize(reader, std::move(data));
-	case AlterTableType::ALTER_COLUMN_TYPE:
-		return ChangeColumnTypeInfo::Deserialize(reader, std::move(data));
-	case AlterTableType::SET_DEFAULT:
-		return SetDefaultInfo::Deserialize(reader, std::move(data));
-	case AlterTableType::FOREIGN_KEY_CONSTRAINT:
-		return AlterForeignKeyInfo::Deserialize(reader, std::move(data));
-	case AlterTableType::SET_NOT_NULL:
-		return SetNotNullInfo::Deserialize(reader, std::move(data));
-	case AlterTableType::DROP_NOT_NULL:
-		return DropNotNullInfo::Deserialize(reader, std::move(data));
-	default:
-		throw SerializationException("Unknown alter table type for deserialization!");
-	}
-}
-
 //===--------------------------------------------------------------------===//
 // RenameColumnInfo
 //===--------------------------------------------------------------------===//
@@ -108,17 +60,6 @@ unique_ptr<AlterInfo> RenameColumnInfo::Copy() const {
 	return make_uniq_base<AlterInfo, RenameColumnInfo>(GetAlterEntryData(), old_name, new_name);
 }
 
-void RenameColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(old_name);
-	writer.WriteString(new_name);
-}
-
-unique_ptr<AlterInfo> RenameColumnInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
-	auto old_name = reader.ReadRequired<string>();
-	auto new_name = reader.ReadRequired<string>();
-	return make_uniq<RenameColumnInfo>(std::move(data), old_name, new_name);
-}
-
 //===--------------------------------------------------------------------===//
 // RenameTableInfo
 //===--------------------------------------------------------------------===//
@@ -136,15 +77,6 @@ unique_ptr<AlterInfo> RenameTableInfo::Copy() const {
 	return make_uniq_base<AlterInfo, RenameTableInfo>(GetAlterEntryData(), new_table_name);
 }
 
-void RenameTableInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(new_table_name);
-}
-
-unique_ptr<AlterInfo> RenameTableInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
-	auto new_name = reader.ReadRequired<string>();
-	return make_uniq<RenameTableInfo>(std::move(data), new_name);
-}
-
 //===--------------------------------------------------------------------===//
 // AddColumnInfo
 //===--------------------------------------------------------------------===//
@@ -164,17 +96,6 @@ unique_ptr<AlterInfo> AddColumnInfo::Copy() const {
 	return make_uniq_base<AlterInfo, AddColumnInfo>(GetAlterEntryData(), new_column.Copy(), if_column_not_exists);
 }
 
-void AddColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteSerializable(new_column);
-	writer.WriteField<bool>(if_column_not_exists);
-}
-
-unique_ptr<AlterInfo> AddColumnInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
-	auto new_column = reader.ReadRequiredSerializable<ColumnDefinition, ColumnDefinition>();
-	auto if_column_not_exists = reader.ReadRequired<bool>();
-	return make_uniq<AddColumnInfo>(std::move(data), std::move(new_column), if_column_not_exists);
-}
-
 //===--------------------------------------------------------------------===//
 // RemoveColumnInfo
 //===--------------------------------------------------------------------===//
@@ -192,19 +113,6 @@ unique_ptr<AlterInfo> RemoveColumnInfo::Copy() const {
 	return make_uniq_base<AlterInfo, RemoveColumnInfo>(GetAlterEntryData(), removed_column, if_column_exists, cascade);
 }
 
-void RemoveColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(removed_column);
-	writer.WriteField<bool>(if_column_exists);
-	writer.WriteField<bool>(cascade);
-}
-
-unique_ptr<AlterInfo> RemoveColumnInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
-	auto new_name = reader.ReadRequired<string>();
-	auto if_column_exists = reader.ReadRequired<bool>();
-	auto cascade = reader.ReadRequired<bool>();
-	return make_uniq<RemoveColumnInfo>(std::move(data), std::move(new_name), if_column_exists, cascade);
-}
-
 //===--------------------------------------------------------------------===//
 // ChangeColumnTypeInfo
 //===--------------------------------------------------------------------===//
@@ -224,20 +132,6 @@ unique_ptr<AlterInfo> ChangeColumnTypeInfo::Copy() const {
 	                                                       expression->Copy());
 }
 
-void ChangeColumnTypeInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(column_name);
-	writer.WriteSerializable(target_type);
-	writer.WriteOptional(expression);
-}
-
-unique_ptr<AlterInfo> ChangeColumnTypeInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
-	auto column_name = reader.ReadRequired<string>();
-	auto target_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto expression = reader.ReadOptional<ParsedExpression>(nullptr);
-	return make_uniq<ChangeColumnTypeInfo>(std::move(data), std::move(column_name), std::move(target_type),
-	                                       std::move(expression));
-}
-
 //===--------------------------------------------------------------------===//
 // SetDefaultInfo
 //===--------------------------------------------------------------------===//
@@ -256,17 +150,6 @@ unique_ptr<AlterInfo> SetDefaultInfo::Copy() const {
 	                                                 expression ? expression->Copy() : nullptr);
 }
 
-void SetDefaultInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(column_name);
-	writer.WriteOptional(expression);
-}
-
-unique_ptr<AlterInfo> SetDefaultInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
-	auto column_name = reader.ReadRequired<string>();
-	auto new_default = reader.ReadOptional<ParsedExpression>(nullptr);
-	return make_uniq<SetDefaultInfo>(std::move(data), std::move(column_name), std::move(new_default));
-}
-
 //===--------------------------------------------------------------------===//
 // SetNotNullInfo
 //===--------------------------------------------------------------------===//
@@ -283,15 +166,6 @@ unique_ptr<AlterInfo> SetNotNullInfo::Copy() const {
 	return make_uniq_base<AlterInfo, SetNotNullInfo>(GetAlterEntryData(), column_name);
 }
 
-void SetNotNullInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(column_name);
-}
-
-unique_ptr<AlterInfo> SetNotNullInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
-	auto column_name = reader.ReadRequired<string>();
-	return make_uniq<SetNotNullInfo>(std::move(data), std::move(column_name));
-}
-
 //===--------------------------------------------------------------------===//
 // DropNotNullInfo
 //===--------------------------------------------------------------------===//
@@ -308,15 +182,6 @@ unique_ptr<AlterInfo> DropNotNullInfo::Copy() const {
 	return make_uniq_base<AlterInfo, DropNotNullInfo>(GetAlterEntryData(), column_name);
 }
 
-void DropNotNullInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(column_name);
-}
-
-unique_ptr<AlterInfo> DropNotNullInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
-	auto column_name = reader.ReadRequired<string>();
-	return make_uniq<DropNotNullInfo>(std::move(data), std::move(column_name));
-}
-
 //===--------------------------------------------------------------------===//
 // AlterForeignKeyInfo
 //===--------------------------------------------------------------------===//
@@ -338,30 +203,10 @@ unique_ptr<AlterInfo> AlterForeignKeyInfo::Copy() const {
 	                                                      pk_keys, fk_keys, type);
 }
 
-void AlterForeignKeyInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(fk_table);
-	writer.WriteList<string>(pk_columns);
-	writer.WriteList<string>(fk_columns);
-	writer.WriteIndexList<PhysicalIndex>(pk_keys);
-	writer.WriteIndexList<PhysicalIndex>(fk_keys);
-	writer.WriteField<AlterForeignKeyType>(type);
-}
-
-unique_ptr<AlterInfo> AlterForeignKeyInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
-	auto fk_table = reader.ReadRequired<string>();
-	auto pk_columns = reader.ReadRequiredList<string>();
-	auto fk_columns = reader.ReadRequiredList<string>();
-	auto pk_keys = reader.ReadRequiredIndexList<PhysicalIndex>();
-	auto fk_keys = reader.ReadRequiredIndexList<PhysicalIndex>();
-	auto type = reader.ReadRequired<AlterForeignKeyType>();
-	return make_uniq<AlterForeignKeyInfo>(std::move(data), std::move(fk_table), std::move(pk_columns),
-	                                      std::move(fk_columns), std::move(pk_keys), std::move(fk_keys), type);
-}
-
 //===--------------------------------------------------------------------===//
 // Alter View
 //===--------------------------------------------------------------------===//
-AlterViewInfo::AlterViewInfo(AlterViewType type) : AlterInfo(AlterType::ALTER_VIEW) {
+AlterViewInfo::AlterViewInfo(AlterViewType type) : AlterInfo(AlterType::ALTER_VIEW), alter_view_type(type) {
 }
 
 AlterViewInfo::AlterViewInfo(AlterViewType type, AlterEntryData data)
@@ -376,31 +221,6 @@ CatalogType AlterViewInfo::GetCatalogType() const {
 	return CatalogType::VIEW_ENTRY;
 }
 
-void AlterViewInfo::Serialize(FieldWriter &writer) const {
-	writer.WriteField<AlterViewType>(alter_view_type);
-	writer.WriteString(catalog);
-	writer.WriteString(schema);
-	writer.WriteString(name);
-	writer.WriteField<OnEntryNotFound>(if_not_found);
-	SerializeAlterView(writer);
-}
-
-unique_ptr<AlterInfo> AlterViewInfo::Deserialize(FieldReader &reader) {
-	auto type = reader.ReadRequired<AlterViewType>();
-	AlterEntryData data;
-	data.catalog = reader.ReadRequired<string>();
-	data.schema = reader.ReadRequired<string>();
-	data.name = reader.ReadRequired<string>();
-	data.if_not_found = reader.ReadRequired<OnEntryNotFound>();
-	unique_ptr<AlterViewInfo> info;
-	switch (type) {
-	case AlterViewType::RENAME_VIEW:
-		return RenameViewInfo::Deserialize(reader, std::move(data));
-	default:
-		throw SerializationException("Unknown alter view type for deserialization!");
-	}
-}
-
 //===--------------------------------------------------------------------===//
 // RenameViewInfo
 //===--------------------------------------------------------------------===//
@@ -416,12 +236,4 @@ unique_ptr<AlterInfo> RenameViewInfo::Copy() const {
 	return make_uniq_base<AlterInfo, RenameViewInfo>(GetAlterEntryData(), new_view_name);
 }
 
-void RenameViewInfo::SerializeAlterView(FieldWriter &writer) const {
-	writer.WriteString(new_view_name);
-}
-
-unique_ptr<AlterInfo> RenameViewInfo::Deserialize(FieldReader &reader, AlterEntryData data) {
-	auto new_name = reader.ReadRequired<string>();
-	return make_uniq<RenameViewInfo>(std::move(data), new_name);
-}
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/attach_info.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/parser/parsed_data/attach_info.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -11,32 +10,4 @@ unique_ptr<AttachInfo> AttachInfo::Copy() const {
 	return result;
 }
 
-void AttachInfo::Serialize(Serializer &main_serializer) const {
-	FieldWriter writer(main_serializer);
-	writer.WriteString(name);
-	writer.WriteString(path);
-	writer.WriteField<uint32_t>(options.size());
-	auto &serializer = writer.GetSerializer();
-	for (auto &kv : options) {
-		serializer.WriteString(kv.first);
-		kv.second.Serialize(serializer);
-	}
-	writer.Finalize();
-}
-
-unique_ptr<ParseInfo> AttachInfo::Deserialize(Deserializer &deserializer) {
-	FieldReader reader(deserializer);
-	auto attach_info = make_uniq<AttachInfo>();
-	attach_info->name = reader.ReadRequired<string>();
-	attach_info->path = reader.ReadRequired<string>();
-	auto default_attach_count = reader.ReadRequired<uint32_t>();
-	auto &source = reader.GetSource();
-	for (idx_t i = 0; i < default_attach_count; i++) {
-		auto name = source.Read<string>();
-		attach_info->options[name] = Value::Deserialize(source);
-	}
-	reader.Finalize();
-	return std::move(attach_info);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_collation_info.cpp

@@ -10,10 +10,6 @@ CreateCollationInfo::CreateCollationInfo(string name_p, ScalarFunction function_
 	internal = true;
 }
 
-void CreateCollationInfo::SerializeInternal(Serializer &) const {
-	throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(type));
-}
-
 unique_ptr<CreateInfo> CreateCollationInfo::Copy() const {
 	auto result = make_uniq<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
 	CopyProperties(*result);