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

package/src/duckdb/src/storage/serialization/serialize_parse_info.cpp

@@ -3,8 +3,8 @@
 // Do not edit this file manually, your changes will be overwritten
 //===----------------------------------------------------------------------===//
 
-#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"
 #include "duckdb/parser/parsed_data/parse_info.hpp"
 #include "duckdb/parser/parsed_data/alter_info.hpp"
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
@@ -19,40 +19,40 @@
 
 namespace duckdb {
 
-void ParseInfo::FormatSerialize(FormatSerializer &serializer) const {
+void ParseInfo::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "info_type", info_type);
 }
 
-unique_ptr<ParseInfo> ParseInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParseInfo> ParseInfo::Deserialize(Deserializer &deserializer) {
 	auto info_type = deserializer.ReadProperty<ParseInfoType>(100, "info_type");
 	unique_ptr<ParseInfo> result;
 	switch (info_type) {
 	case ParseInfoType::ALTER_INFO:
-		result = AlterInfo::FormatDeserialize(deserializer);
+		result = AlterInfo::Deserialize(deserializer);
 		break;
 	case ParseInfoType::ATTACH_INFO:
-		result = AttachInfo::FormatDeserialize(deserializer);
+		result = AttachInfo::Deserialize(deserializer);
 		break;
 	case ParseInfoType::COPY_INFO:
-		result = CopyInfo::FormatDeserialize(deserializer);
+		result = CopyInfo::Deserialize(deserializer);
 		break;
 	case ParseInfoType::DETACH_INFO:
-		result = DetachInfo::FormatDeserialize(deserializer);
+		result = DetachInfo::Deserialize(deserializer);
 		break;
 	case ParseInfoType::DROP_INFO:
-		result = DropInfo::FormatDeserialize(deserializer);
+		result = DropInfo::Deserialize(deserializer);
 		break;
 	case ParseInfoType::LOAD_INFO:
-		result = LoadInfo::FormatDeserialize(deserializer);
+		result = LoadInfo::Deserialize(deserializer);
 		break;
 	case ParseInfoType::PRAGMA_INFO:
-		result = PragmaInfo::FormatDeserialize(deserializer);
+		result = PragmaInfo::Deserialize(deserializer);
 		break;
 	case ParseInfoType::TRANSACTION_INFO:
-		result = TransactionInfo::FormatDeserialize(deserializer);
+		result = TransactionInfo::Deserialize(deserializer);
 		break;
 	case ParseInfoType::VACUUM_INFO:
-		result = VacuumInfo::FormatDeserialize(deserializer);
+		result = VacuumInfo::Deserialize(deserializer);
 		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of ParseInfo!");
@@ -60,8 +60,8 @@ unique_ptr<ParseInfo> ParseInfo::FormatDeserialize(FormatDeserializer &deseriali
 	return result;
 }
 
-void AlterInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ParseInfo::FormatSerialize(serializer);
+void AlterInfo::Serialize(Serializer &serializer) const {
+	ParseInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "type", type);
 	serializer.WriteProperty(201, "catalog", catalog);
 	serializer.WriteProperty(202, "schema", schema);
@@ -70,7 +70,7 @@ void AlterInfo::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(205, "allow_internal", allow_internal);
 }
 
-unique_ptr<ParseInfo> AlterInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParseInfo> AlterInfo::Deserialize(Deserializer &deserializer) {
 	auto type = deserializer.ReadProperty<AlterType>(200, "type");
 	auto catalog = deserializer.ReadProperty<string>(201, "catalog");
 	auto schema = deserializer.ReadProperty<string>(202, "schema");
@@ -80,10 +80,10 @@ unique_ptr<ParseInfo> AlterInfo::FormatDeserialize(FormatDeserializer &deseriali
 	unique_ptr<AlterInfo> result;
 	switch (type) {
 	case AlterType::ALTER_TABLE:
-		result = AlterTableInfo::FormatDeserialize(deserializer);
+		result = AlterTableInfo::Deserialize(deserializer);
 		break;
 	case AlterType::ALTER_VIEW:
-		result = AlterViewInfo::FormatDeserialize(deserializer);
+		result = AlterViewInfo::Deserialize(deserializer);
 		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of AlterInfo!");
@@ -96,41 +96,41 @@ unique_ptr<ParseInfo> AlterInfo::FormatDeserialize(FormatDeserializer &deseriali
 	return std::move(result);
 }
 
-void AlterTableInfo::FormatSerialize(FormatSerializer &serializer) const {
-	AlterInfo::FormatSerialize(serializer);
+void AlterTableInfo::Serialize(Serializer &serializer) const {
+	AlterInfo::Serialize(serializer);
 	serializer.WriteProperty(300, "alter_table_type", alter_table_type);
 }
 
-unique_ptr<AlterInfo> AlterTableInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<AlterInfo> AlterTableInfo::Deserialize(Deserializer &deserializer) {
 	auto alter_table_type = deserializer.ReadProperty<AlterTableType>(300, "alter_table_type");
 	unique_ptr<AlterTableInfo> result;
 	switch (alter_table_type) {
 	case AlterTableType::ADD_COLUMN:
-		result = AddColumnInfo::FormatDeserialize(deserializer);
+		result = AddColumnInfo::Deserialize(deserializer);
 		break;
 	case AlterTableType::ALTER_COLUMN_TYPE:
-		result = ChangeColumnTypeInfo::FormatDeserialize(deserializer);
+		result = ChangeColumnTypeInfo::Deserialize(deserializer);
 		break;
 	case AlterTableType::DROP_NOT_NULL:
-		result = DropNotNullInfo::FormatDeserialize(deserializer);
+		result = DropNotNullInfo::Deserialize(deserializer);
 		break;
 	case AlterTableType::FOREIGN_KEY_CONSTRAINT:
-		result = AlterForeignKeyInfo::FormatDeserialize(deserializer);
+		result = AlterForeignKeyInfo::Deserialize(deserializer);
 		break;
 	case AlterTableType::REMOVE_COLUMN:
-		result = RemoveColumnInfo::FormatDeserialize(deserializer);
+		result = RemoveColumnInfo::Deserialize(deserializer);
 		break;
 	case AlterTableType::RENAME_COLUMN:
-		result = RenameColumnInfo::FormatDeserialize(deserializer);
+		result = RenameColumnInfo::Deserialize(deserializer);
 		break;
 	case AlterTableType::RENAME_TABLE:
-		result = RenameTableInfo::FormatDeserialize(deserializer);
+		result = RenameTableInfo::Deserialize(deserializer);
 		break;
 	case AlterTableType::SET_DEFAULT:
-		result = SetDefaultInfo::FormatDeserialize(deserializer);
+		result = SetDefaultInfo::Deserialize(deserializer);
 		break;
 	case AlterTableType::SET_NOT_NULL:
-		result = SetNotNullInfo::FormatDeserialize(deserializer);
+		result = SetNotNullInfo::Deserialize(deserializer);
 		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of AlterTableInfo!");
@@ -138,17 +138,17 @@ unique_ptr<AlterInfo> AlterTableInfo::FormatDeserialize(FormatDeserializer &dese
 	return std::move(result);
 }
 
-void AlterViewInfo::FormatSerialize(FormatSerializer &serializer) const {
-	AlterInfo::FormatSerialize(serializer);
+void AlterViewInfo::Serialize(Serializer &serializer) const {
+	AlterInfo::Serialize(serializer);
 	serializer.WriteProperty(300, "alter_view_type", alter_view_type);
 }
 
-unique_ptr<AlterInfo> AlterViewInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<AlterInfo> AlterViewInfo::Deserialize(Deserializer &deserializer) {
 	auto alter_view_type = deserializer.ReadProperty<AlterViewType>(300, "alter_view_type");
 	unique_ptr<AlterViewInfo> result;
 	switch (alter_view_type) {
 	case AlterViewType::RENAME_VIEW:
-		result = RenameViewInfo::FormatDeserialize(deserializer);
+		result = RenameViewInfo::Deserialize(deserializer);
 		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of AlterViewInfo!");
@@ -156,21 +156,21 @@ unique_ptr<AlterInfo> AlterViewInfo::FormatDeserialize(FormatDeserializer &deser
 	return std::move(result);
 }
 
-void AddColumnInfo::FormatSerialize(FormatSerializer &serializer) const {
-	AlterTableInfo::FormatSerialize(serializer);
+void AddColumnInfo::Serialize(Serializer &serializer) const {
+	AlterTableInfo::Serialize(serializer);
 	serializer.WriteProperty(400, "new_column", new_column);
 	serializer.WriteProperty(401, "if_column_not_exists", if_column_not_exists);
 }
 
-unique_ptr<AlterTableInfo> AddColumnInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<AlterTableInfo> AddColumnInfo::Deserialize(Deserializer &deserializer) {
 	auto new_column = deserializer.ReadProperty<ColumnDefinition>(400, "new_column");
 	auto result = duckdb::unique_ptr<AddColumnInfo>(new AddColumnInfo(std::move(new_column)));
 	deserializer.ReadProperty(401, "if_column_not_exists", result->if_column_not_exists);
 	return std::move(result);
 }
 
-void AlterForeignKeyInfo::FormatSerialize(FormatSerializer &serializer) const {
-	AlterTableInfo::FormatSerialize(serializer);
+void AlterForeignKeyInfo::Serialize(Serializer &serializer) const {
+	AlterTableInfo::Serialize(serializer);
 	serializer.WriteProperty(400, "fk_table", fk_table);
 	serializer.WriteProperty(401, "pk_columns", pk_columns);
 	serializer.WriteProperty(402, "fk_columns", fk_columns);
@@ -179,7 +179,7 @@ void AlterForeignKeyInfo::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(405, "alter_fk_type", type);
 }
 
-unique_ptr<AlterTableInfo> AlterForeignKeyInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<AlterTableInfo> AlterForeignKeyInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<AlterForeignKeyInfo>(new AlterForeignKeyInfo());
 	deserializer.ReadProperty(400, "fk_table", result->fk_table);
 	deserializer.ReadProperty(401, "pk_columns", result->pk_columns);
@@ -190,14 +190,14 @@ unique_ptr<AlterTableInfo> AlterForeignKeyInfo::FormatDeserialize(FormatDeserial
 	return std::move(result);
 }
 
-void AttachInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ParseInfo::FormatSerialize(serializer);
+void AttachInfo::Serialize(Serializer &serializer) const {
+	ParseInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "name", name);
 	serializer.WriteProperty(201, "path", path);
 	serializer.WriteProperty(202, "options", options);
 }
 
-unique_ptr<ParseInfo> AttachInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParseInfo> AttachInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<AttachInfo>(new AttachInfo());
 	deserializer.ReadProperty(200, "name", result->name);
 	deserializer.ReadProperty(201, "path", result->path);
@@ -205,14 +205,14 @@ unique_ptr<ParseInfo> AttachInfo::FormatDeserialize(FormatDeserializer &deserial
 	return std::move(result);
 }
 
-void ChangeColumnTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
-	AlterTableInfo::FormatSerialize(serializer);
+void ChangeColumnTypeInfo::Serialize(Serializer &serializer) const {
+	AlterTableInfo::Serialize(serializer);
 	serializer.WriteProperty(400, "column_name", column_name);
 	serializer.WriteProperty(401, "target_type", target_type);
 	serializer.WriteProperty(402, "expression", expression);
 }
 
-unique_ptr<AlterTableInfo> ChangeColumnTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<AlterTableInfo> ChangeColumnTypeInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<ChangeColumnTypeInfo>(new ChangeColumnTypeInfo());
 	deserializer.ReadProperty(400, "column_name", result->column_name);
 	deserializer.ReadProperty(401, "target_type", result->target_type);
@@ -220,8 +220,8 @@ unique_ptr<AlterTableInfo> ChangeColumnTypeInfo::FormatDeserialize(FormatDeseria
 	return std::move(result);
 }
 
-void CopyInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ParseInfo::FormatSerialize(serializer);
+void CopyInfo::Serialize(Serializer &serializer) const {
+	ParseInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "catalog", catalog);
 	serializer.WriteProperty(201, "schema", schema);
 	serializer.WriteProperty(202, "table", table);
@@ -232,7 +232,7 @@ void CopyInfo::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(207, "options", options);
 }
 
-unique_ptr<ParseInfo> CopyInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParseInfo> CopyInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CopyInfo>(new CopyInfo());
 	deserializer.ReadProperty(200, "catalog", result->catalog);
 	deserializer.ReadProperty(201, "schema", result->schema);
@@ -245,21 +245,21 @@ unique_ptr<ParseInfo> CopyInfo::FormatDeserialize(FormatDeserializer &deserializ
 	return std::move(result);
 }
 
-void DetachInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ParseInfo::FormatSerialize(serializer);
+void DetachInfo::Serialize(Serializer &serializer) const {
+	ParseInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "name", name);
 	serializer.WriteProperty(201, "if_not_found", if_not_found);
 }
 
-unique_ptr<ParseInfo> DetachInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParseInfo> DetachInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<DetachInfo>(new DetachInfo());
 	deserializer.ReadProperty(200, "name", result->name);
 	deserializer.ReadProperty(201, "if_not_found", result->if_not_found);
 	return std::move(result);
 }
 
-void DropInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ParseInfo::FormatSerialize(serializer);
+void DropInfo::Serialize(Serializer &serializer) const {
+	ParseInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "type", type);
 	serializer.WriteProperty(201, "catalog", catalog);
 	serializer.WriteProperty(202, "schema", schema);
@@ -269,7 +269,7 @@ void DropInfo::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(206, "allow_drop_internal", allow_drop_internal);
 }
 
-unique_ptr<ParseInfo> DropInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParseInfo> DropInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<DropInfo>(new DropInfo());
 	deserializer.ReadProperty(200, "type", result->type);
 	deserializer.ReadProperty(201, "catalog", result->catalog);
@@ -281,25 +281,25 @@ unique_ptr<ParseInfo> DropInfo::FormatDeserialize(FormatDeserializer &deserializ
 	return std::move(result);
 }
 
-void DropNotNullInfo::FormatSerialize(FormatSerializer &serializer) const {
-	AlterTableInfo::FormatSerialize(serializer);
+void DropNotNullInfo::Serialize(Serializer &serializer) const {
+	AlterTableInfo::Serialize(serializer);
 	serializer.WriteProperty(400, "column_name", column_name);
 }
 
-unique_ptr<AlterTableInfo> DropNotNullInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<AlterTableInfo> DropNotNullInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<DropNotNullInfo>(new DropNotNullInfo());
 	deserializer.ReadProperty(400, "column_name", result->column_name);
 	return std::move(result);
 }
 
-void LoadInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ParseInfo::FormatSerialize(serializer);
+void LoadInfo::Serialize(Serializer &serializer) const {
+	ParseInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "filename", filename);
 	serializer.WriteProperty(201, "load_type", load_type);
 	serializer.WriteProperty(202, "repository", repository);
 }
 
-unique_ptr<ParseInfo> LoadInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParseInfo> LoadInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LoadInfo>(new LoadInfo());
 	deserializer.ReadProperty(200, "filename", result->filename);
 	deserializer.ReadProperty(201, "load_type", result->load_type);
@@ -307,14 +307,14 @@ unique_ptr<ParseInfo> LoadInfo::FormatDeserialize(FormatDeserializer &deserializ
 	return std::move(result);
 }
 
-void PragmaInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ParseInfo::FormatSerialize(serializer);
+void PragmaInfo::Serialize(Serializer &serializer) const {
+	ParseInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "name", name);
 	serializer.WriteProperty(201, "parameters", parameters);
 	serializer.WriteProperty(202, "named_parameters", named_parameters);
 }
 
-unique_ptr<ParseInfo> PragmaInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParseInfo> PragmaInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<PragmaInfo>(new PragmaInfo());
 	deserializer.ReadProperty(200, "name", result->name);
 	deserializer.ReadProperty(201, "parameters", result->parameters);
@@ -322,14 +322,14 @@ unique_ptr<ParseInfo> PragmaInfo::FormatDeserialize(FormatDeserializer &deserial
 	return std::move(result);
 }
 
-void RemoveColumnInfo::FormatSerialize(FormatSerializer &serializer) const {
-	AlterTableInfo::FormatSerialize(serializer);
+void RemoveColumnInfo::Serialize(Serializer &serializer) const {
+	AlterTableInfo::Serialize(serializer);
 	serializer.WriteProperty(400, "removed_column", removed_column);
 	serializer.WriteProperty(401, "if_column_exists", if_column_exists);
 	serializer.WriteProperty(402, "cascade", cascade);
 }
 
-unique_ptr<AlterTableInfo> RemoveColumnInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<AlterTableInfo> RemoveColumnInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<RemoveColumnInfo>(new RemoveColumnInfo());
 	deserializer.ReadProperty(400, "removed_column", result->removed_column);
 	deserializer.ReadProperty(401, "if_column_exists", result->if_column_exists);
@@ -337,82 +337,82 @@ unique_ptr<AlterTableInfo> RemoveColumnInfo::FormatDeserialize(FormatDeserialize
 	return std::move(result);
 }
 
-void RenameColumnInfo::FormatSerialize(FormatSerializer &serializer) const {
-	AlterTableInfo::FormatSerialize(serializer);
+void RenameColumnInfo::Serialize(Serializer &serializer) const {
+	AlterTableInfo::Serialize(serializer);
 	serializer.WriteProperty(400, "old_name", old_name);
 	serializer.WriteProperty(401, "new_name", new_name);
 }
 
-unique_ptr<AlterTableInfo> RenameColumnInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<AlterTableInfo> RenameColumnInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<RenameColumnInfo>(new RenameColumnInfo());
 	deserializer.ReadProperty(400, "old_name", result->old_name);
 	deserializer.ReadProperty(401, "new_name", result->new_name);
 	return std::move(result);
 }
 
-void RenameTableInfo::FormatSerialize(FormatSerializer &serializer) const {
-	AlterTableInfo::FormatSerialize(serializer);
+void RenameTableInfo::Serialize(Serializer &serializer) const {
+	AlterTableInfo::Serialize(serializer);
 	serializer.WriteProperty(400, "new_table_name", new_table_name);
 }
 
-unique_ptr<AlterTableInfo> RenameTableInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<AlterTableInfo> RenameTableInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<RenameTableInfo>(new RenameTableInfo());
 	deserializer.ReadProperty(400, "new_table_name", result->new_table_name);
 	return std::move(result);
 }
 
-void RenameViewInfo::FormatSerialize(FormatSerializer &serializer) const {
-	AlterViewInfo::FormatSerialize(serializer);
+void RenameViewInfo::Serialize(Serializer &serializer) const {
+	AlterViewInfo::Serialize(serializer);
 	serializer.WriteProperty(400, "new_view_name", new_view_name);
 }
 
-unique_ptr<AlterViewInfo> RenameViewInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<AlterViewInfo> RenameViewInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<RenameViewInfo>(new RenameViewInfo());
 	deserializer.ReadProperty(400, "new_view_name", result->new_view_name);
 	return std::move(result);
 }
 
-void SetDefaultInfo::FormatSerialize(FormatSerializer &serializer) const {
-	AlterTableInfo::FormatSerialize(serializer);
+void SetDefaultInfo::Serialize(Serializer &serializer) const {
+	AlterTableInfo::Serialize(serializer);
 	serializer.WriteProperty(400, "column_name", column_name);
 	serializer.WritePropertyWithDefault(401, "expression", expression, unique_ptr<ParsedExpression>());
 }
 
-unique_ptr<AlterTableInfo> SetDefaultInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<AlterTableInfo> SetDefaultInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<SetDefaultInfo>(new SetDefaultInfo());
 	deserializer.ReadProperty(400, "column_name", result->column_name);
 	deserializer.ReadPropertyWithDefault(401, "expression", result->expression, unique_ptr<ParsedExpression>());
 	return std::move(result);
 }
 
-void SetNotNullInfo::FormatSerialize(FormatSerializer &serializer) const {
-	AlterTableInfo::FormatSerialize(serializer);
+void SetNotNullInfo::Serialize(Serializer &serializer) const {
+	AlterTableInfo::Serialize(serializer);
 	serializer.WriteProperty(400, "column_name", column_name);
 }
 
-unique_ptr<AlterTableInfo> SetNotNullInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<AlterTableInfo> SetNotNullInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<SetNotNullInfo>(new SetNotNullInfo());
 	deserializer.ReadProperty(400, "column_name", result->column_name);
 	return std::move(result);
 }
 
-void TransactionInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ParseInfo::FormatSerialize(serializer);
+void TransactionInfo::Serialize(Serializer &serializer) const {
+	ParseInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "type", type);
 }
 
-unique_ptr<ParseInfo> TransactionInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParseInfo> TransactionInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<TransactionInfo>(new TransactionInfo());
 	deserializer.ReadProperty(200, "type", result->type);
 	return std::move(result);
 }
 
-void VacuumInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ParseInfo::FormatSerialize(serializer);
+void VacuumInfo::Serialize(Serializer &serializer) const {
+	ParseInfo::Serialize(serializer);
 	serializer.WriteProperty(200, "options", options);
 }
 
-unique_ptr<ParseInfo> VacuumInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ParseInfo> VacuumInfo::Deserialize(Deserializer &deserializer) {
 	auto options = deserializer.ReadProperty<VacuumOptions>(200, "options");
 	auto result = duckdb::unique_ptr<VacuumInfo>(new VacuumInfo(options));
 	return std::move(result);