duckdb 0.7.2-dev3515.0 → 0.7.2-dev3666.0

package/src/duckdb/src/include/duckdb/parser/parsed_data/drop_info.hpp

@@ -15,8 +15,7 @@
 namespace duckdb {
 
 struct DropInfo : public ParseInfo {
-	DropInfo() : catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), cascade(false) {
-	}
+	DropInfo();
 
 	//! The catalog type to drop
 	CatalogType type;
@@ -35,43 +34,10 @@ struct DropInfo : public ParseInfo {
 	bool allow_drop_internal = false;
 
 public:
-	unique_ptr<DropInfo> Copy() const {
-		auto result = make_uniq<DropInfo>();
-		result->type = type;
-		result->catalog = catalog;
-		result->schema = schema;
-		result->name = name;
-		result->if_not_found = if_not_found;
-		result->cascade = cascade;
-		result->allow_drop_internal = allow_drop_internal;
-		return result;
-	}
+	unique_ptr<DropInfo> Copy() const;
 
-	void Serialize(Serializer &serializer) const {
-		FieldWriter writer(serializer);
-		writer.WriteField<CatalogType>(type);
-		writer.WriteString(catalog);
-		writer.WriteString(schema);
-		writer.WriteString(name);
-		writer.WriteField(if_not_found);
-		writer.WriteField(cascade);
-		writer.WriteField(allow_drop_internal);
-		writer.Finalize();
-	}
-
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer) {
-		FieldReader reader(deserializer);
-		auto drop_info = make_uniq<DropInfo>();
-		drop_info->type = reader.ReadRequired<CatalogType>();
-		drop_info->catalog = reader.ReadRequired<string>();
-		drop_info->schema = reader.ReadRequired<string>();
-		drop_info->name = reader.ReadRequired<string>();
-		drop_info->if_not_found = reader.ReadRequired<OnEntryNotFound>();
-		drop_info->cascade = reader.ReadRequired<bool>();
-		drop_info->allow_drop_internal = reader.ReadRequired<bool>();
-		reader.Finalize();
-		return std::move(drop_info);
-	}
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/transaction_info.hpp

@@ -15,11 +15,14 @@ namespace duckdb {
 enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
 
 struct TransactionInfo : public ParseInfo {
-	explicit TransactionInfo(TransactionType type) : type(type) {
-	}
+	explicit TransactionInfo(TransactionType type);
 
 	//! The type of transaction statement
 	TransactionType type;
+
+public:
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/vacuum_info.hpp

@@ -17,22 +17,16 @@
 namespace duckdb {
 
 struct VacuumOptions {
+	VacuumOptions() : vacuum(false), analyze(false) {
+	}
+
 	bool vacuum;
 	bool analyze;
 };
 
 struct VacuumInfo : public ParseInfo {
 public:
-	explicit VacuumInfo(VacuumOptions options) : options(options), has_table(false) {};
-
-	unique_ptr<VacuumInfo> Copy() {
-		auto result = make_uniq<VacuumInfo>(options);
-		result->has_table = has_table;
-		if (has_table) {
-			result->ref = ref->Copy();
-		}
-		return result;
-	}
+	explicit VacuumInfo(VacuumOptions options);
 
 	const VacuumOptions options;
 
@@ -42,6 +36,12 @@ public:
 	optional_ptr<TableCatalogEntry> table;
 	unordered_map<idx_t, idx_t> column_id_map;
 	vector<string> columns;
+
+public:
+	unique_ptr<VacuumInfo> Copy();
+
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parser_extension.hpp

@@ -17,7 +17,7 @@ namespace duckdb {
 //! The ParserExtensionInfo holds static information relevant to the parser extension
 //! It is made available in the parse_function, and will be kept alive as long as the database system is kept alive
 struct ParserExtensionInfo {
-	DUCKDB_API virtual ~ParserExtensionInfo() {
+	virtual ~ParserExtensionInfo() {
 	}
 };
 
@@ -29,7 +29,7 @@ enum class ParserExtensionResultType : uint8_t { PARSE_SUCCESSFUL, DISPLAY_ORIGI
 //! The ParserExtensionParseData holds the result of a successful parse step
 //! It will be passed along to the subsequent plan function
 struct ParserExtensionParseData {
-	DUCKDB_API virtual ~ParserExtensionParseData() {
+	virtual ~ParserExtensionParseData() {
 	}
 
 	virtual unique_ptr<ParserExtensionParseData> Copy() const = 0;

package/src/duckdb/src/include/duckdb/parser/sql_statement.hpp

@@ -41,7 +41,7 @@ protected:
 	SQLStatement(const SQLStatement &other) = default;
 
 public:
-	DUCKDB_API virtual string ToString() const {
+	virtual string ToString() const {
 		throw InternalException("ToString not supported for this type of SQLStatement: '%s'",
 		                        StatementTypeToString(type));
 	}

package/src/duckdb/src/include/duckdb/parser/statement/select_statement.hpp

@@ -26,7 +26,7 @@ public:
 	static constexpr const StatementType TYPE = StatementType::SELECT_STATEMENT;
 
 public:
-	DUCKDB_API SelectStatement() : SQLStatement(StatementType::SELECT_STATEMENT) {
+	SelectStatement() : SQLStatement(StatementType::SELECT_STATEMENT) {
 	}
 
 	//! The main query node

package/src/duckdb/src/include/duckdb/planner/operator_extension.hpp

@@ -16,7 +16,7 @@ namespace duckdb {
 
 //! The OperatorExtensionInfo holds static information relevant to the operator extension
 struct OperatorExtensionInfo {
-	DUCKDB_API virtual ~OperatorExtensionInfo() {
+	virtual ~OperatorExtensionInfo() {
 	}
 };
 
@@ -37,7 +37,7 @@ public:
 	virtual unique_ptr<LogicalExtensionOperator> Deserialize(LogicalDeserializationState &state,
 	                                                         FieldReader &reader) = 0;
 
-	DUCKDB_API virtual ~OperatorExtension() {
+	virtual ~OperatorExtension() {
 	}
 };
 

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

@@ -20,7 +20,7 @@ class TransactionManager;
 
 //! The StorageExtensionInfo holds static information relevant to the storage extension
 struct StorageExtensionInfo {
-	DUCKDB_API virtual ~StorageExtensionInfo() {
+	virtual ~StorageExtensionInfo() {
 	}
 };
 
@@ -43,7 +43,7 @@ public:
 	//! Additional info passed to the various storage functions
 	shared_ptr<StorageExtensionInfo> storage_info;
 
-	DUCKDB_API virtual ~StorageExtension() {
+	virtual ~StorageExtension() {
 	}
 };
 

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

@@ -0,0 +1,42 @@
+#include "duckdb/parser/parsed_data/attach_info.hpp"
+#include "duckdb/common/field_writer.hpp"
+
+namespace duckdb {
+
+unique_ptr<AttachInfo> AttachInfo::Copy() const {
+	auto result = make_uniq<AttachInfo>();
+	result->name = name;
+	result->path = path;
+	result->options = options;
+	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_index_info.cpp

@@ -5,7 +5,6 @@
 namespace duckdb {
 
 unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
-
 	auto result = make_uniq<CreateIndexInfo>();
 	CopyProperties(*result);
 
@@ -27,24 +26,20 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 }
 
 void CreateIndexInfo::SerializeInternal(Serializer &serializer) const {
-
 	FieldWriter writer(serializer);
 	writer.WriteField(index_type);
 	writer.WriteString(index_name);
 	writer.WriteField(constraint_type);
 
-	writer.WriteSerializableList<ParsedExpression>(expressions);
 	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);
 
@@ -53,13 +48,11 @@ unique_ptr<CreateIndexInfo> CreateIndexInfo::Deserialize(Deserializer &deseriali
 	result->index_name = reader.ReadRequired<string>();
 	result->constraint_type = reader.ReadRequired<IndexConstraintType>();
 
-	result->expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
 	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;
 }

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

@@ -4,18 +4,13 @@
 #include "duckdb/parser/parsed_data/create_schema_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
+#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
 #include "duckdb/parser/parsed_data/create_database_info.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
 #include "duckdb/parser/parsed_data/alter_info.hpp"
+#include "duckdb/parser/parsed_data/create_macro_info.hpp"
 
 namespace duckdb {
-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>();
-}
 
 void CreateInfo::Serialize(Serializer &serializer) const {
 	serializer.Write(type);
@@ -28,6 +23,15 @@ void CreateInfo::Serialize(Serializer &serializer) const {
 	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) {
@@ -41,6 +45,13 @@ unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
 		return CreateViewInfo::Deserialize(deserializer);
 	case CatalogType::DATABASE_ENTRY:
 		return CreateDatabaseInfo::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));
 	}

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

@@ -0,0 +1,46 @@
+#include "duckdb/parser/parsed_data/create_macro_info.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
+
+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>();
+	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

@@ -0,0 +1,56 @@
+#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
+
+namespace duckdb {
+
+CreateSequenceInfo::CreateSequenceInfo()
+    : CreateInfo(CatalogType::SEQUENCE_ENTRY, INVALID_SCHEMA), name(string()), usage_count(0), increment(1),
+      min_value(1), max_value(NumericLimits<int64_t>::Maximum()), start_value(1), cycle(false) {
+}
+
+unique_ptr<CreateInfo> CreateSequenceInfo::Copy() const {
+	auto result = make_uniq<CreateSequenceInfo>();
+	CopyProperties(*result);
+	result->name = name;
+	result->schema = schema;
+	result->usage_count = usage_count;
+	result->increment = increment;
+	result->min_value = min_value;
+	result->max_value = max_value;
+	result->start_value = start_value;
+	result->cycle = cycle;
+	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_type_info.cpp

@@ -0,0 +1,47 @@
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
+
+namespace duckdb {
+
+CreateTypeInfo::CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
+}
+CreateTypeInfo::CreateTypeInfo(string name_p, LogicalType type_p)
+    : CreateInfo(CatalogType::TYPE_ENTRY), name(std::move(name_p)), type(std::move(type_p)) {
+}
+
+unique_ptr<CreateInfo> CreateTypeInfo::Copy() const {
+	auto result = make_uniq<CreateTypeInfo>();
+	CopyProperties(*result);
+	result->name = name;
+	result->type = type;
+	if (query) {
+		result->query = query->Copy();
+	}
+	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

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

@@ -0,0 +1,34 @@
+#include "duckdb/parser/parsed_data/detach_info.hpp"
+#include "duckdb/common/field_writer.hpp"
+
+namespace duckdb {
+
+DetachInfo::DetachInfo() {
+}
+
+unique_ptr<DetachInfo> DetachInfo::Copy() const {
+	auto result = make_uniq<DetachInfo>();
+	result->name = name;
+	result->if_not_found = if_not_found;
+	return result;
+}
+
+void DetachInfo::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteString(name);
+	writer.WriteField(if_not_found);
+	writer.Finalize();
+}
+
+unique_ptr<ParseInfo> DetachInfo::Deserialize(Deserializer &deserializer) {
+	auto result = make_uniq<DetachInfo>();
+
+	FieldReader reader(deserializer);
+	result->name = reader.ReadRequired<string>();
+	result->if_not_found = reader.ReadRequired<OnEntryNotFound>();
+	reader.Finalize();
+
+	return std::move(result);
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,46 @@
+#include "duckdb/parser/parsed_data/drop_info.hpp"
+
+namespace duckdb {
+
+DropInfo::DropInfo() : catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), cascade(false) {
+}
+
+unique_ptr<DropInfo> DropInfo::Copy() const {
+	auto result = make_uniq<DropInfo>();
+	result->type = type;
+	result->catalog = catalog;
+	result->schema = schema;
+	result->name = name;
+	result->if_not_found = if_not_found;
+	result->cascade = cascade;
+	result->allow_drop_internal = allow_drop_internal;
+	return result;
+}
+
+void DropInfo::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteField<CatalogType>(type);
+	writer.WriteString(catalog);
+	writer.WriteString(schema);
+	writer.WriteString(name);
+	writer.WriteField(if_not_found);
+	writer.WriteField(cascade);
+	writer.WriteField(allow_drop_internal);
+	writer.Finalize();
+}
+
+unique_ptr<ParseInfo> DropInfo::Deserialize(Deserializer &deserializer) {
+	FieldReader reader(deserializer);
+	auto drop_info = make_uniq<DropInfo>();
+	drop_info->type = reader.ReadRequired<CatalogType>();
+	drop_info->catalog = reader.ReadRequired<string>();
+	drop_info->schema = reader.ReadRequired<string>();
+	drop_info->name = reader.ReadRequired<string>();
+	drop_info->if_not_found = reader.ReadRequired<OnEntryNotFound>();
+	drop_info->cascade = reader.ReadRequired<bool>();
+	drop_info->allow_drop_internal = reader.ReadRequired<bool>();
+	reader.Finalize();
+	return std::move(drop_info);
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,24 @@
+#include "duckdb/parser/parsed_data/transaction_info.hpp"
+#include "duckdb/common/field_writer.hpp"
+
+namespace duckdb {
+
+TransactionInfo::TransactionInfo(TransactionType type) : type(type) {
+}
+
+void TransactionInfo::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteField(type);
+	writer.Finalize();
+}
+
+unique_ptr<ParseInfo> TransactionInfo::Deserialize(Deserializer &deserializer) {
+	FieldReader reader(deserializer);
+	auto transaction_type = reader.ReadRequired<TransactionType>();
+	reader.Finalize();
+
+	auto transaction_info = make_uniq<TransactionInfo>(transaction_type);
+	return std::move(transaction_info);
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,37 @@
+#include "duckdb/parser/parsed_data/vacuum_info.hpp"
+#include "duckdb/common/field_writer.hpp"
+
+namespace duckdb {
+
+VacuumInfo::VacuumInfo(VacuumOptions options) : options(options), has_table(false) {
+}
+
+unique_ptr<VacuumInfo> VacuumInfo::Copy() {
+	auto result = make_uniq<VacuumInfo>(options);
+	result->has_table = has_table;
+	if (has_table) {
+		result->ref = ref->Copy();
+	}
+	return result;
+}
+
+void VacuumInfo::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteField(options.analyze);
+	writer.WriteField(options.vacuum);
+	writer.Finalize();
+}
+
+unique_ptr<ParseInfo> VacuumInfo::Deserialize(Deserializer &deserializer) {
+
+	VacuumOptions options;
+	FieldReader reader(deserializer);
+	options.analyze = reader.ReadRequired<bool>();
+	options.vacuum = reader.ReadRequired<bool>();
+	reader.Finalize();
+
+	auto vacuum_info = make_uniq<VacuumInfo>(options);
+	return std::move(vacuum_info);
+}
+
+} // namespace duckdb