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

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);

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

@@ -8,10 +8,6 @@ CreateCopyFunctionInfo::CreateCopyFunctionInfo(CopyFunction function_p)
 	internal = true;
 }
 
-void CreateCopyFunctionInfo::SerializeInternal(Serializer &) const {
-	throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(type));
-}
-
 unique_ptr<CreateInfo> CreateCopyFunctionInfo::Copy() const {
 	auto result = make_uniq<CreateCopyFunctionInfo>(function);
 	CopyProperties(*result);

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

@@ -1,7 +1,5 @@
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
@@ -26,50 +24,4 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 	return std::move(result);
 }
 
-void CreateIndexInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField(index_type);
-	writer.WriteString(table);
-	writer.WriteString(index_name);
-	writer.WriteField(constraint_type);
-
-	writer.WriteSerializableList<ParsedExpression>(parsed_expressions);
-
-	writer.WriteRegularSerializableList(scan_types);
-	writer.WriteList<string>(names);
-	writer.WriteList<column_t>(column_ids);
-	writer.WriteString(index_type_name);
-	writer.WriteField((idx_t)options.size());
-	for (auto &kv : options) {
-		writer.WriteString(kv.first);
-		writer.WriteSerializable(kv.second);
-	}
-	writer.Finalize();
-}
-
-unique_ptr<CreateIndexInfo> CreateIndexInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateIndexInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->index_type = reader.ReadRequired<IndexType>();
-	result->table = reader.ReadRequired<string>();
-	result->index_name = reader.ReadRequired<string>();
-	result->constraint_type = reader.ReadRequired<IndexConstraintType>();
-
-	result->parsed_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
-
-	result->scan_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	result->names = reader.ReadRequiredList<string>();
-	result->column_ids = reader.ReadRequiredList<column_t>();
-	result->index_type_name = reader.ReadRequired<string>();
-	auto options_count = reader.ReadRequired<idx_t>();
-	for (idx_t i = 0; i < options_count; i++) {
-		auto key = reader.ReadRequired<string>();
-		auto value = reader.ReadRequiredSerializable<Value, Value>();
-		result->options[key] = value;
-	}
-	reader.Finalize();
-	return result;
-}
 } // namespace duckdb

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

@@ -11,53 +11,6 @@
 
 namespace duckdb {
 
-void CreateInfo::Serialize(Serializer &serializer) const {
-	serializer.Write(type);
-	serializer.WriteString(catalog);
-	serializer.WriteString(schema);
-	serializer.Write(on_conflict);
-	serializer.Write(temporary);
-	serializer.Write(internal);
-	serializer.WriteString(sql);
-	SerializeInternal(serializer);
-}
-
-void CreateInfo::DeserializeBase(Deserializer &deserializer) {
-	this->catalog = deserializer.Read<string>();
-	this->schema = deserializer.Read<string>();
-	this->on_conflict = deserializer.Read<OnCreateConflict>();
-	this->temporary = deserializer.Read<bool>();
-	this->internal = deserializer.Read<bool>();
-	this->sql = deserializer.Read<string>();
-}
-
-unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.Read<CatalogType>();
-	switch (type) {
-	case CatalogType::INDEX_ENTRY:
-		return CreateIndexInfo::Deserialize(deserializer);
-	case CatalogType::TABLE_ENTRY:
-		return CreateTableInfo::Deserialize(deserializer);
-	case CatalogType::SCHEMA_ENTRY:
-		return CreateSchemaInfo::Deserialize(deserializer);
-	case CatalogType::VIEW_ENTRY:
-		return CreateViewInfo::Deserialize(deserializer);
-	case CatalogType::TYPE_ENTRY:
-		return CreateTypeInfo::Deserialize(deserializer);
-	case CatalogType::MACRO_ENTRY:
-	case CatalogType::TABLE_MACRO_ENTRY:
-		return CreateMacroInfo::Deserialize(deserializer);
-	case CatalogType::SEQUENCE_ENTRY:
-		return CreateSequenceInfo::Deserialize(deserializer);
-	default:
-		throw NotImplementedException("Cannot deserialize '%s'", CatalogTypeToString(type));
-	}
-}
-
-unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &source, PlanDeserializationState &state) {
-	return Deserialize(source);
-}
-
 void CreateInfo::CopyProperties(CreateInfo &other) const {
 	other.type = type;
 	other.catalog = catalog;

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

@@ -5,42 +5,15 @@
 
 namespace duckdb {
 
-CreateMacroInfo::CreateMacroInfo() : CreateFunctionInfo(CatalogType::MACRO_ENTRY, INVALID_SCHEMA) {
-}
-
 CreateMacroInfo::CreateMacroInfo(CatalogType type) : CreateFunctionInfo(type, INVALID_SCHEMA) {
 }
 
 unique_ptr<CreateInfo> CreateMacroInfo::Copy() const {
-	auto result = make_uniq<CreateMacroInfo>();
+	auto result = make_uniq<CreateMacroInfo>(type);
 	result->function = function->Copy();
 	result->name = name;
 	CopyProperties(*result);
 	return std::move(result);
 }
 
-void CreateMacroInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteSerializable(*function);
-	writer.Finalize();
-}
-
-unique_ptr<CreateMacroInfo> CreateMacroInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateMacroInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->name = reader.ReadRequired<string>();
-	result->function = reader.ReadRequiredSerializable<MacroFunction>();
-	reader.Finalize();
-
-	if (result->function->type == MacroType::TABLE_MACRO) {
-		result->type = CatalogType::TABLE_MACRO_ENTRY;
-	} else {
-		result->type = CatalogType::MACRO_ENTRY;
-	}
-	return result;
-}
-
 } // namespace duckdb