duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

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,13 +25,12 @@ unique_ptr<AlterInfo> ChangeOwnershipInfo::Copy() const {
 	                                                      owner_name, if_not_found);
 }
 
-void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
-	throw InternalException("ChangeOwnershipInfo cannot be serialized");
-}
-
 //===--------------------------------------------------------------------===//
 // AlterTableInfo
 //===--------------------------------------------------------------------===//
+AlterTableInfo::AlterTableInfo(AlterTableType type) : AlterInfo(AlterType::ALTER_TABLE), alter_table_type(type) {
+}
+
 AlterTableInfo::AlterTableInfo(AlterTableType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_TABLE, std::move(data.catalog), std::move(data.schema), std::move(data.name),
                 data.if_not_found),
@@ -44,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
 //===--------------------------------------------------------------------===//
@@ -94,30 +49,27 @@ RenameColumnInfo::RenameColumnInfo(AlterEntryData data, string old_name_p, strin
     : AlterTableInfo(AlterTableType::RENAME_COLUMN, std::move(data)), old_name(std::move(old_name_p)),
       new_name(std::move(new_name_p)) {
 }
-RenameColumnInfo::~RenameColumnInfo() {
-}
 
-unique_ptr<AlterInfo> RenameColumnInfo::Copy() const {
-	return make_uniq_base<AlterInfo, RenameColumnInfo>(GetAlterEntryData(), old_name, new_name);
+RenameColumnInfo::RenameColumnInfo() : AlterTableInfo(AlterTableType::RENAME_COLUMN) {
 }
 
-void RenameColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
-	writer.WriteString(old_name);
-	writer.WriteString(new_name);
+RenameColumnInfo::~RenameColumnInfo() {
 }
 
-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);
+unique_ptr<AlterInfo> RenameColumnInfo::Copy() const {
+	return make_uniq_base<AlterInfo, RenameColumnInfo>(GetAlterEntryData(), old_name, new_name);
 }
 
 //===--------------------------------------------------------------------===//
 // RenameTableInfo
 //===--------------------------------------------------------------------===//
+RenameTableInfo::RenameTableInfo() : AlterTableInfo(AlterTableType::RENAME_TABLE) {
+}
+
 RenameTableInfo::RenameTableInfo(AlterEntryData data, string new_name_p)
     : AlterTableInfo(AlterTableType::RENAME_TABLE, std::move(data)), new_table_name(std::move(new_name_p)) {
 }
+
 RenameTableInfo::~RenameTableInfo() {
 }
 
@@ -125,18 +77,13 @@ 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
 //===--------------------------------------------------------------------===//
+AddColumnInfo::AddColumnInfo(ColumnDefinition new_column_p)
+    : AlterTableInfo(AlterTableType::ADD_COLUMN), new_column(std::move(new_column_p)) {
+}
+
 AddColumnInfo::AddColumnInfo(AlterEntryData data, ColumnDefinition new_column, bool if_column_not_exists)
     : AlterTableInfo(AlterTableType::ADD_COLUMN, std::move(data)), new_column(std::move(new_column)),
       if_column_not_exists(if_column_not_exists) {
@@ -149,20 +96,12 @@ 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
 //===--------------------------------------------------------------------===//
+RemoveColumnInfo::RemoveColumnInfo() : AlterTableInfo(AlterTableType::REMOVE_COLUMN) {
+}
+
 RemoveColumnInfo::RemoveColumnInfo(AlterEntryData data, string removed_column, bool if_column_exists, bool cascade)
     : AlterTableInfo(AlterTableType::REMOVE_COLUMN, std::move(data)), removed_column(std::move(removed_column)),
       if_column_exists(if_column_exists), cascade(cascade) {
@@ -174,22 +113,12 @@ 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
 //===--------------------------------------------------------------------===//
+ChangeColumnTypeInfo::ChangeColumnTypeInfo() : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE) {
+}
+
 ChangeColumnTypeInfo::ChangeColumnTypeInfo(AlterEntryData data, string column_name, LogicalType target_type,
                                            unique_ptr<ParsedExpression> expression)
     : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE, std::move(data)), column_name(std::move(column_name)),
@@ -203,23 +132,12 @@ 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
 //===--------------------------------------------------------------------===//
+SetDefaultInfo::SetDefaultInfo() : AlterTableInfo(AlterTableType::SET_DEFAULT) {
+}
+
 SetDefaultInfo::SetDefaultInfo(AlterEntryData data, string column_name_p, unique_ptr<ParsedExpression> new_default)
     : AlterTableInfo(AlterTableType::SET_DEFAULT, std::move(data)), column_name(std::move(column_name_p)),
       expression(std::move(new_default)) {
@@ -232,20 +150,12 @@ 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
 //===--------------------------------------------------------------------===//
+SetNotNullInfo::SetNotNullInfo() : AlterTableInfo(AlterTableType::SET_NOT_NULL) {
+}
+
 SetNotNullInfo::SetNotNullInfo(AlterEntryData data, string column_name_p)
     : AlterTableInfo(AlterTableType::SET_NOT_NULL, std::move(data)), column_name(std::move(column_name_p)) {
 }
@@ -256,18 +166,12 @@ 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
 //===--------------------------------------------------------------------===//
+DropNotNullInfo::DropNotNullInfo() : AlterTableInfo(AlterTableType::DROP_NOT_NULL) {
+}
+
 DropNotNullInfo::DropNotNullInfo(AlterEntryData data, string column_name_p)
     : AlterTableInfo(AlterTableType::DROP_NOT_NULL, std::move(data)), column_name(std::move(column_name_p)) {
 }
@@ -278,18 +182,12 @@ 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
 //===--------------------------------------------------------------------===//
+AlterForeignKeyInfo::AlterForeignKeyInfo() : AlterTableInfo(AlterTableType::FOREIGN_KEY_CONSTRAINT) {
+}
+
 AlterForeignKeyInfo::AlterForeignKeyInfo(AlterEntryData data, string fk_table, vector<string> pk_columns,
                                          vector<string> fk_columns, vector<PhysicalIndex> pk_keys,
                                          vector<PhysicalIndex> fk_keys, AlterForeignKeyType type_p)
@@ -305,29 +203,12 @@ 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), alter_view_type(type) {
+}
+
 AlterViewInfo::AlterViewInfo(AlterViewType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_VIEW, std::move(data.catalog), std::move(data.schema), std::move(data.name),
                 data.if_not_found),
@@ -340,34 +221,11 @@ 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
 //===--------------------------------------------------------------------===//
+RenameViewInfo::RenameViewInfo() : AlterViewInfo(AlterViewType::RENAME_VIEW) {
+}
 RenameViewInfo::RenameViewInfo(AlterEntryData data, string new_name_p)
     : AlterViewInfo(AlterViewType::RENAME_VIEW, std::move(data)), new_view_name(std::move(new_name_p)) {
 }
@@ -378,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 {
@@ -11,7 +9,7 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 	result->index_type = index_type;
 	result->index_name = index_name;
 	result->constraint_type = constraint_type;
-	result->table = unique_ptr_cast<TableRef, BaseTableRef>(table->Copy());
+	result->table = table;
 	for (auto &expr : expressions) {
 		result->expressions.push_back(expr->Copy());
 	}
@@ -22,38 +20,8 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 	result->scan_types = scan_types;
 	result->names = names;
 	result->column_ids = column_ids;
+	result->options = options;
 	return std::move(result);
 }
 
-void CreateIndexInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField(index_type);
-	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.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->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>();
-	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

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

@@ -24,33 +24,4 @@ unique_ptr<CreateInfo> CreateSequenceInfo::Copy() const {
 	return std::move(result);
 }
 
-void CreateSequenceInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteField(usage_count);
-	writer.WriteField(increment);
-	writer.WriteField(min_value);
-	writer.WriteField(max_value);
-	writer.WriteField(start_value);
-	writer.WriteField(cycle);
-	writer.Finalize();
-}
-
-unique_ptr<CreateSequenceInfo> CreateSequenceInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateSequenceInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->name = reader.ReadRequired<string>();
-	result->usage_count = reader.ReadRequired<uint64_t>();
-	result->increment = reader.ReadRequired<int64_t>();
-	result->min_value = reader.ReadRequired<int64_t>();
-	result->max_value = reader.ReadRequired<int64_t>();
-	result->start_value = reader.ReadRequired<int64_t>();
-	result->cycle = reader.ReadRequired<bool>();
-	reader.Finalize();
-
-	return result;
-}
-
 } // namespace duckdb

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

@@ -16,29 +16,6 @@ CreateTableInfo::CreateTableInfo(SchemaCatalogEntry &schema, string name_p)
     : CreateTableInfo(schema.catalog.GetName(), schema.name, std::move(name_p)) {
 }
 
-void CreateTableInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(table);
-	columns.Serialize(writer);
-	writer.WriteSerializableList(constraints);
-	writer.WriteOptional(query);
-	writer.Finalize();
-}
-
-unique_ptr<CreateTableInfo> CreateTableInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateTableInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->table = reader.ReadRequired<string>();
-	result->columns = ColumnList::Deserialize(reader);
-	result->constraints = reader.ReadRequiredSerializableList<Constraint>();
-	result->query = reader.ReadOptional<SelectStatement>(nullptr);
-	reader.Finalize();
-
-	return result;
-}
-
 unique_ptr<CreateInfo> CreateTableInfo::Copy() const {
 	auto result = make_uniq<CreateTableInfo>(catalog, schema, table);
 	CopyProperties(*result);

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

@@ -22,26 +22,4 @@ unique_ptr<CreateInfo> CreateTypeInfo::Copy() const {
 	return std::move(result);
 }
 
-void CreateTypeInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteSerializable(type);
-	if (query) {
-		throw InternalException("Cannot serialize CreateTypeInfo with query");
-	}
-	writer.Finalize();
-}
-
-unique_ptr<CreateTypeInfo> CreateTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateTypeInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->name = reader.ReadRequired<string>();
-	result->type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	reader.Finalize();
-
-	return result;
-}
-
 } // namespace duckdb