duckdb 0.8.2-dev2090.0 → 0.8.2-dev2208.0

package/src/duckdb/src/planner/logical_operator_visitor.cpp

@@ -70,13 +70,10 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_DEPENDENT_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-			auto &delim_join = op.Cast<LogicalDelimJoin>();
-			for (auto &expr : delim_join.duplicate_eliminated_columns) {
-				callback(&expr);
-			}
-		}
 		auto &join = op.Cast<LogicalComparisonJoin>();
+		for (auto &expr : join.duplicate_eliminated_columns) {
+			callback(&expr);
+		}
 		for (auto &cond : join.conditions) {
 			callback(&cond.left);
 			callback(&cond.right);

package/src/duckdb/src/planner/operator/logical_comparison_join.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
 #include "duckdb/common/enum_util.hpp"
 namespace duckdb {
@@ -26,6 +25,7 @@ void LogicalComparisonJoin::Serialize(FieldWriter &writer) const {
 	LogicalJoin::Serialize(writer);
 	writer.WriteRegularSerializableList(mark_types);
 	writer.WriteRegularSerializableList(conditions);
+	writer.WriteSerializableList(duplicate_eliminated_columns);
 }
 
 void LogicalComparisonJoin::Deserialize(LogicalComparisonJoin &comparison_join, LogicalDeserializationState &state,
@@ -33,6 +33,7 @@ void LogicalComparisonJoin::Deserialize(LogicalComparisonJoin &comparison_join,
 	LogicalJoin::Deserialize(comparison_join, state, reader);
 	comparison_join.mark_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 	comparison_join.conditions = reader.ReadRequiredSerializableList<JoinCondition, JoinCondition>(state.gstate);
+	comparison_join.duplicate_eliminated_columns = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 }
 
 unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(LogicalDeserializationState &state,
@@ -42,17 +43,4 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(LogicalDeserializ
 	return std::move(result);
 }
 
-unique_ptr<LogicalOperator> LogicalComparisonJoin::FromDelimJoin(LogicalDelimJoin &delim_join) {
-	auto new_join = make_uniq<LogicalComparisonJoin>(delim_join.join_type);
-	new_join->children = std::move(delim_join.children);
-	new_join->conditions = std::move(delim_join.conditions);
-	new_join->types = std::move(delim_join.types);
-	new_join->mark_types = std::move(delim_join.mark_types);
-	new_join->mark_index = delim_join.mark_index;
-	new_join->left_projection_map = std::move(delim_join.left_projection_map);
-	new_join->right_projection_map = std::move(delim_join.right_projection_map);
-	new_join->join_stats = std::move(delim_join.join_stats);
-	return std::move(new_join);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_copy_to_file.cpp

@@ -59,6 +59,14 @@ unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializatio
 	return std::move(result);
 }
 
+void LogicalCopyToFile::FormatSerialize(FormatSerializer &serializer) const {
+	throw SerializationException("LogicalCopyToFile not implemented yet");
+}
+
+unique_ptr<LogicalOperator> LogicalCopyToFile::FormatDeserialize(FormatDeserializer &deserializer) {
+	throw SerializationException("LogicalCopyToFile not implemented yet");
+}
+
 idx_t LogicalCopyToFile::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

package/src/duckdb/src/planner/operator/logical_create_index.cpp

@@ -6,11 +6,9 @@
 
 namespace duckdb {
 
-LogicalCreateIndex::LogicalCreateIndex(unique_ptr<FunctionData> bind_data_p, unique_ptr<CreateIndexInfo> info_p,
-                                       vector<unique_ptr<Expression>> expressions_p, TableCatalogEntry &table_p,
-                                       TableFunction function_p)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX), bind_data(std::move(bind_data_p)),
-      info(std::move(info_p)), table(table_p), function(std::move(function_p)) {
+LogicalCreateIndex::LogicalCreateIndex(unique_ptr<CreateIndexInfo> info_p, vector<unique_ptr<Expression>> expressions_p,
+                                       TableCatalogEntry &table_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX), info(std::move(info_p)), table(table_p) {
 
 	for (auto &expr : expressions_p) {
 		this->unbound_expressions.push_back(expr->Copy());
@@ -22,12 +20,21 @@ LogicalCreateIndex::LogicalCreateIndex(unique_ptr<FunctionData> bind_data_p, uni
 	}
 }
 
+LogicalCreateIndex::LogicalCreateIndex(ClientContext &context, unique_ptr<CreateInfo> info_p,
+                                       vector<unique_ptr<Expression>> expressions_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX),
+      info(unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(info_p))), table(BindTable(context, *info)) {
+	for (auto &expr : expressions_p) {
+		this->unbound_expressions.push_back(expr->Copy());
+	}
+	this->expressions = std::move(expressions_p);
+}
+
 void LogicalCreateIndex::Serialize(FieldWriter &writer) const {
 	writer.WriteOptional(info);
 	writer.WriteString(table.catalog.GetName());
 	writer.WriteString(table.schema.name);
 	writer.WriteString(table.name);
-	FunctionSerializer::SerializeBase<TableFunction>(writer, function, bind_data.get());
 	writer.WriteSerializableList(unbound_expressions);
 }
 
@@ -38,10 +45,6 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	auto catalog = reader.ReadRequired<string>();
 	auto schema = reader.ReadRequired<string>();
 	auto table_name = reader.ReadRequired<string>();
-	unique_ptr<FunctionData> bind_data;
-	bool has_deserialize;
-	auto function = FunctionSerializer::DeserializeBaseInternal<TableFunction, TableFunctionCatalogEntry>(
-	    reader, state.gstate, CatalogType::TABLE_FUNCTION_ENTRY, bind_data, has_deserialize);
 	auto unbound_expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 	if (info->type != CatalogType::INDEX_ENTRY) {
 		throw InternalException("Unexpected type: '%s', expected '%s'", CatalogTypeToString(info->type),
@@ -49,12 +52,18 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	}
 	auto index_info = unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(info));
 	auto &table = Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table_name);
-	return make_uniq<LogicalCreateIndex>(std::move(bind_data), std::move(index_info), std::move(unbound_expressions),
-	                                     table, std::move(function));
+	return make_uniq<LogicalCreateIndex>(std::move(index_info), std::move(unbound_expressions), table);
 }
 
 void LogicalCreateIndex::ResolveTypes() {
 	types.emplace_back(LogicalType::BIGINT);
 }
 
+TableCatalogEntry &LogicalCreateIndex::BindTable(ClientContext &context, CreateIndexInfo &info) {
+	auto &catalog = info.catalog;
+	auto &schema = info.schema;
+	auto &table_name = info.table;
+	return Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table_name);
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_extension_operator.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/planner/operator/logical_extension_operator.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 unique_ptr<LogicalExtensionOperator> LogicalExtensionOperator::Deserialize(LogicalDeserializationState &state,
@@ -15,4 +17,26 @@ unique_ptr<LogicalExtensionOperator> LogicalExtensionOperator::Deserialize(Logic
 
 	throw SerializationException("No serialization method exists for extension: " + extension_name);
 }
+
+void LogicalExtensionOperator::FormatSerialize(FormatSerializer &serializer) const {
+	LogicalOperator::FormatSerialize(serializer);
+	serializer.WriteProperty("extension_name", GetExtensionName());
+}
+
+unique_ptr<LogicalOperator> LogicalExtensionOperator::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto &config = DBConfig::GetConfig(deserializer.Get<ClientContext &>());
+	auto extension_name = deserializer.ReadProperty<string>("extension_name");
+	for (auto &extension : config.operator_extensions) {
+		if (extension->GetName() == extension_name) {
+			return extension->FormatDeserialize(deserializer);
+		}
+	}
+	throw SerializationException("No deserialization method exists for extension: " + extension_name);
+}
+
+string LogicalExtensionOperator::GetExtensionName() const {
+	throw SerializationException("LogicalExtensionOperator::GetExtensionName not implemented which is required for "
+	                             "serializing extension operators");
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_get.cpp

@@ -8,9 +8,14 @@
 #include "duckdb/function/table/table_scan.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/storage/data_table.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
+LogicalGet::LogicalGet() : LogicalOperator(LogicalOperatorType::LOGICAL_GET) {
+}
+
 LogicalGet::LogicalGet(idx_t table_index, TableFunction function, unique_ptr<FunctionData> bind_data,
                        vector<LogicalType> returned_types, vector<string> returned_names)
     : LogicalOperator(LogicalOperatorType::LOGICAL_GET), table_index(table_index), function(std::move(function)),
@@ -199,6 +204,70 @@ unique_ptr<LogicalOperator> LogicalGet::Deserialize(LogicalDeserializationState
 	return std::move(result);
 }
 
+void LogicalGet::FormatSerialize(FormatSerializer &serializer) const {
+	LogicalOperator::FormatSerialize(serializer);
+	serializer.WriteProperty("table_index", table_index);
+	serializer.WriteProperty("returned_types", returned_types);
+	serializer.WriteProperty("names", names);
+	serializer.WriteProperty("column_ids", column_ids);
+	serializer.WriteProperty("projection_ids", projection_ids);
+	serializer.WriteProperty("table_filters", table_filters);
+	FunctionSerializer::FormatSerialize(serializer, function, bind_data.get());
+	if (!function.format_serialize) {
+		D_ASSERT(!function.format_deserialize);
+		// no serialize method: serialize input values and named_parameters for rebinding purposes
+		serializer.WriteProperty("parameters", parameters);
+		serializer.WriteProperty("named_parameters", named_parameters);
+		serializer.WriteProperty("input_table_types", input_table_types);
+		serializer.WriteProperty("input_table_names", input_table_names);
+	}
+	serializer.WriteProperty("projected_input", projected_input);
+}
+
+unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = unique_ptr<LogicalGet>(new LogicalGet());
+	deserializer.ReadProperty("table_index", result->table_index);
+	deserializer.ReadProperty("returned_types", result->returned_types);
+	deserializer.ReadProperty("names", result->names);
+	deserializer.ReadProperty("column_ids", result->column_ids);
+	deserializer.ReadProperty("projection_ids", result->projection_ids);
+	deserializer.ReadProperty("table_filters", result->table_filters);
+	auto entry = FunctionSerializer::FormatDeserializeBase<TableFunction, TableFunctionCatalogEntry>(
+	    deserializer, CatalogType::TABLE_FUNCTION_ENTRY);
+	auto &function = entry.first;
+	auto has_serialize = entry.second;
+
+	unique_ptr<FunctionData> bind_data;
+	if (!has_serialize) {
+		deserializer.ReadProperty("parameters", result->parameters);
+		deserializer.ReadProperty("named_parameters", result->named_parameters);
+		deserializer.ReadProperty("input_table_types", result->input_table_types);
+		deserializer.ReadProperty("input_table_names", result->input_table_names);
+		TableFunctionBindInput input(result->parameters, result->named_parameters, result->input_table_types,
+		                             result->input_table_names, function.function_info.get());
+
+		vector<LogicalType> bind_return_types;
+		vector<string> bind_names;
+		if (!function.bind) {
+			throw InternalException("Table function \"%s\" has neither bind nor (de)serialize", function.name);
+		}
+		bind_data = function.bind(deserializer.Get<ClientContext &>(), input, bind_return_types, bind_names);
+		if (result->returned_types != bind_return_types) {
+			throw SerializationException(
+			    "Table function deserialization failure - bind returned different return types than were serialized");
+		}
+		// names can actually be different because of aliases - only the sizes cannot be different
+		if (result->names.size() != bind_names.size()) {
+			throw SerializationException(
+			    "Table function deserialization failure - bind returned different returned names than were serialized");
+		}
+	} else {
+		bind_data = FunctionSerializer::FunctionDeserialize(deserializer, function);
+	}
+	deserializer.ReadProperty("projected_input", result->projected_input);
+	return std::move(result);
+}
+
 vector<idx_t> LogicalGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

package/src/duckdb/src/planner/planner.cpp

@@ -176,7 +176,6 @@ void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op
 	}
 
 	BufferedSerializer serializer;
-	serializer.is_query_plan = true;
 	try {
 		op->Serialize(serializer);
 	} catch (NotImplementedException &ex) {

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -131,7 +131,6 @@ void SingleFileCheckpointReader::LoadFromStorage() {
 	con.BeginTransaction();
 	// create the MetaBlockReader to read from the storage
 	MetaBlockReader reader(block_manager, meta_block);
-	reader.SetCatalog(catalog.GetAttached().GetCatalog());
 	reader.SetContext(*con.context);
 	LoadCheckpoint(*con.context, reader);
 	con.Commit();
@@ -414,10 +413,7 @@ void CheckpointWriter::WriteType(TypeCatalogEntry &type) {
 
 void CheckpointReader::ReadType(ClientContext &context, MetaBlockReader &reader) {
 	auto info = TypeCatalogEntry::Deserialize(reader);
-	auto &catalog_entry = catalog.CreateType(context, *info)->Cast<TypeCatalogEntry>();
-	if (info->type.id() == LogicalTypeId::ENUM) {
-		EnumType::SetCatalog(info->type, &catalog_entry);
-	}
+	catalog.CreateType(context, info->Cast<CreateTypeInfo>());
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/storage/meta_block_reader.cpp

@@ -43,10 +43,6 @@ ClientContext &MetaBlockReader::GetContext() {
 	return *context;
 }
 
-optional_ptr<Catalog> MetaBlockReader::GetCatalog() {
-	return catalog;
-}
-
 void MetaBlockReader::ReadNewBlock(block_id_t id) {
 	auto &buffer_manager = block_manager.buffer_manager;
 
@@ -65,11 +61,6 @@ void MetaBlockReader::ReadNewBlock(block_id_t id) {
 	offset = sizeof(block_id_t);
 }
 
-void MetaBlockReader::SetCatalog(Catalog &catalog_p) {
-	D_ASSERT(!catalog);
-	catalog = &catalog_p;
-}
-
 void MetaBlockReader::SetContext(ClientContext &context_p) {
 	D_ASSERT(!context);
 	context = &context_p;

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

@@ -75,6 +75,7 @@ unique_ptr<CreateInfo> CreateInfo::FormatDeserialize(FormatDeserializer &deseria
 void CreateIndexInfo::FormatSerialize(FormatSerializer &serializer) const {
 	CreateInfo::FormatSerialize(serializer);
 	serializer.WriteProperty("name", index_name);
+	serializer.WriteProperty("table", table);
 	serializer.WriteProperty("index_type", index_type);
 	serializer.WriteProperty("constraint_type", constraint_type);
 	serializer.WriteProperty("parsed_expressions", parsed_expressions);
@@ -85,6 +86,7 @@ void CreateIndexInfo::FormatSerialize(FormatSerializer &serializer) const {
 unique_ptr<CreateInfo> CreateIndexInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CreateIndexInfo>(new CreateIndexInfo());
 	deserializer.ReadProperty("name", result->index_name);
+	deserializer.ReadProperty("table", result->table);
 	deserializer.ReadProperty("index_type", result->index_type);
 	deserializer.ReadProperty("constraint_type", result->constraint_type);
 	deserializer.ReadProperty("parsed_expressions", result->parsed_expressions);

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

@@ -22,6 +22,9 @@ unique_ptr<Expression> Expression::FormatDeserialize(FormatDeserializer &deseria
 	deserializer.Set<ExpressionType>(type);
 	unique_ptr<Expression> result;
 	switch (expression_class) {
+	case ExpressionClass::BOUND_AGGREGATE:
+		result = BoundAggregateExpression::FormatDeserialize(deserializer);
+		break;
 	case ExpressionClass::BOUND_BETWEEN:
 		result = BoundBetweenExpression::FormatDeserialize(deserializer);
 		break;
@@ -46,6 +49,9 @@ unique_ptr<Expression> Expression::FormatDeserialize(FormatDeserializer &deseria
 	case ExpressionClass::BOUND_DEFAULT:
 		result = BoundDefaultExpression::FormatDeserialize(deserializer);
 		break;
+	case ExpressionClass::BOUND_FUNCTION:
+		result = BoundFunctionExpression::FormatDeserialize(deserializer);
+		break;
 	case ExpressionClass::BOUND_LAMBDA:
 		result = BoundLambdaExpression::FormatDeserialize(deserializer);
 		break;
@@ -64,6 +70,9 @@ unique_ptr<Expression> Expression::FormatDeserialize(FormatDeserializer &deseria
 	case ExpressionClass::BOUND_UNNEST:
 		result = BoundUnnestExpression::FormatDeserialize(deserializer);
 		break;
+	case ExpressionClass::BOUND_WINDOW:
+		result = BoundWindowExpression::FormatDeserialize(deserializer);
+		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of Expression!");
 	}

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

@@ -31,6 +31,9 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
 		result = LogicalAnyJoin::FormatDeserialize(deserializer);
 		break;
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
+		result = LogicalComparisonJoin::FormatDeserialize(deserializer);
+		break;
 	case LogicalOperatorType::LOGICAL_ATTACH:
 		result = LogicalSimple::FormatDeserialize(deserializer);
 		break;
@@ -40,6 +43,12 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 		result = LogicalComparisonJoin::FormatDeserialize(deserializer);
 		break;
+	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
+		result = LogicalCopyToFile::FormatDeserialize(deserializer);
+		break;
+	case LogicalOperatorType::LOGICAL_CREATE_INDEX:
+		result = LogicalCreateIndex::FormatDeserialize(deserializer);
+		break;
 	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
 		result = LogicalCreate::FormatDeserialize(deserializer);
 		break;
@@ -70,6 +79,9 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
 	case LogicalOperatorType::LOGICAL_DELIM_GET:
 		result = LogicalDelimGet::FormatDeserialize(deserializer);
 		break;
+	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
+		result = LogicalComparisonJoin::FormatDeserialize(deserializer);
+		break;
 	case LogicalOperatorType::LOGICAL_DETACH:
 		result = LogicalSimple::FormatDeserialize(deserializer);
 		break;
@@ -94,9 +106,15 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
 	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
 		result = LogicalExpressionGet::FormatDeserialize(deserializer);
 		break;
+	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
+		result = LogicalExtensionOperator::FormatDeserialize(deserializer);
+		break;
 	case LogicalOperatorType::LOGICAL_FILTER:
 		result = LogicalFilter::FormatDeserialize(deserializer);
 		break;
+	case LogicalOperatorType::LOGICAL_GET:
+		result = LogicalGet::FormatDeserialize(deserializer);
+		break;
 	case LogicalOperatorType::LOGICAL_INSERT:
 		result = LogicalInsert::FormatDeserialize(deserializer);
 		break;
@@ -255,6 +273,7 @@ void LogicalComparisonJoin::FormatSerialize(FormatSerializer &serializer) const
 	serializer.WriteProperty("right_projection_map", right_projection_map);
 	serializer.WriteProperty("conditions", conditions);
 	serializer.WriteProperty("mark_types", mark_types);
+	serializer.WriteProperty("duplicate_eliminated_columns", duplicate_eliminated_columns);
 }
 
 unique_ptr<LogicalOperator> LogicalComparisonJoin::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -265,6 +284,7 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::FormatDeserialize(FormatDeser
 	deserializer.ReadProperty("right_projection_map", result->right_projection_map);
 	deserializer.ReadProperty("conditions", result->conditions);
 	deserializer.ReadProperty("mark_types", result->mark_types);
+	deserializer.ReadProperty("duplicate_eliminated_columns", result->duplicate_eliminated_columns);
 	return std::move(result);
 }
 
@@ -279,6 +299,19 @@ unique_ptr<LogicalOperator> LogicalCreate::FormatDeserialize(FormatDeserializer
 	return std::move(result);
 }
 
+void LogicalCreateIndex::FormatSerialize(FormatSerializer &serializer) const {
+	LogicalOperator::FormatSerialize(serializer);
+	serializer.WriteProperty("info", *info);
+	serializer.WriteProperty("unbound_expressions", unbound_expressions);
+}
+
+unique_ptr<LogicalOperator> LogicalCreateIndex::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>("info");
+	auto unbound_expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("unbound_expressions");
+	auto result = duckdb::unique_ptr<LogicalCreateIndex>(new LogicalCreateIndex(deserializer.Get<ClientContext &>(), std::move(info), std::move(unbound_expressions)));
+	return std::move(result);
+}
+
 void LogicalCreateTable::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
 	serializer.WriteProperty("catalog", schema.ParentCatalog().GetName());