duckdb 0.8.2-dev2133.0 → 0.8.2-dev2278.0

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -24,7 +24,6 @@
 #include "duckdb/planner/operator/logical_create_index.hpp"
 #include "duckdb/planner/operator/logical_create_table.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_distinct.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
@@ -39,6 +38,7 @@
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/catalog/duck_catalog.hpp"
+#include "duckdb/function/table/table_scan.hpp"
 
 namespace duckdb {
 
@@ -260,23 +260,7 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, optional
 		} else {
 			type = Catalog::GetType(context, INVALID_CATALOG, schema, user_type_name);
 		}
-	} else if (type.id() == LogicalTypeId::ENUM) {
-		auto enum_type_name = EnumType::GetTypeName(type);
-		optional_ptr<TypeCatalogEntry> enum_type_catalog;
-		if (catalog) {
-			enum_type_catalog =
-			    catalog->GetEntry<TypeCatalogEntry>(context, schema, enum_type_name, OnEntryNotFound::RETURN_NULL);
-			if (!enum_type_catalog) {
-				// look in the system catalog if the type was not found
-				enum_type_catalog = Catalog::GetEntry<TypeCatalogEntry>(context, SYSTEM_CATALOG, schema, enum_type_name,
-				                                                        OnEntryNotFound::RETURN_NULL);
-			}
-		} else {
-			enum_type_catalog = Catalog::GetEntry<TypeCatalogEntry>(context, INVALID_CATALOG, schema, enum_type_name,
-			                                                        OnEntryNotFound::RETURN_NULL);
-		}
-
-		EnumType::SetCatalog(type, enum_type_catalog.get());
+		BindLogicalType(context, type, catalog, schema);
 	}
 }
 
@@ -483,10 +467,14 @@ unique_ptr<LogicalOperator> DuckCatalog::BindCreateIndex(Binder &binder, CreateS
 	create_index_info->scan_types.emplace_back(LogicalType::ROW_TYPE);
 	create_index_info->names = get.names;
 	create_index_info->column_ids = get.column_ids;
+	auto &bind_data = get.bind_data->Cast<TableScanBindData>();
+	bind_data.is_create_index = true;
+	get.column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
 
 	// the logical CREATE INDEX also needs all fields to scan the referenced table
-	return make_uniq<LogicalCreateIndex>(std::move(get.bind_data), std::move(create_index_info), std::move(expressions),
-	                                     table, std::move(get.function));
+	auto result = make_uniq<LogicalCreateIndex>(std::move(create_index_info), std::move(expressions), table);
+	result->children.push_back(std::move(plan));
+	return std::move(result);
 }
 
 BoundStatement Binder::Bind(CreateStatement &stmt) {
@@ -548,7 +536,6 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		if (plan->type != LogicalOperatorType::LOGICAL_GET) {
 			throw BinderException("Cannot create index on a view!");
 		}
-
 		result.plan = table.catalog.BindCreateIndex(*this, stmt, table, std::move(plan));
 		break;
 	}
@@ -653,8 +640,6 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			// We set b to be an alias for the underlying type of a
 			auto inner_type = Catalog::GetType(context, schema.catalog.GetName(), schema.name,
 			                                   UserType::GetTypeName(create_type_info.type));
-			// clear to nullptr, we don't need this
-			EnumType::SetCatalog(inner_type, nullptr);
 			inner_type.SetAlias(create_type_info.name);
 			create_type_info.type = inner_type;
 		}

package/src/duckdb/src/planner/binder/statement/bind_create_table.cpp

@@ -292,30 +292,6 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 			ExpressionBinder::TestCollation(context, StringType::GetCollation(column.Type()));
 		}
 		BindLogicalType(context, column.TypeMutable(), &result->schema.catalog);
-		// We add a catalog dependency
-		auto type_dependency = EnumType::GetCatalog(column.Type());
-
-		if (type_dependency) {
-			// Only if the USER comes from a create type
-			if (schema.catalog.IsTemporaryCatalog() && column.Type().id() == LogicalTypeId::ENUM) {
-				// for enum types that are used in tables in the temp catalog, we need to
-				// make a copy of the enum type definition that is accessible there
-				auto enum_type = type_dependency->user_type;
-				auto &enum_entries = EnumType::GetValuesInsertOrder(enum_type);
-				auto enum_size = EnumType::GetSize(enum_type);
-				Vector copy_enum_entries_vec(LogicalType::VARCHAR, enum_size);
-				auto copy_enum_entries_ptr = FlatVector::GetData<string_t>(copy_enum_entries_vec);
-				auto enum_entries_ptr = FlatVector::GetData<string_t>(enum_entries);
-				for (idx_t enum_idx = 0; enum_idx < enum_size; enum_idx++) {
-					copy_enum_entries_ptr[enum_idx] =
-					    StringVector::AddStringOrBlob(copy_enum_entries_vec, enum_entries_ptr[enum_idx]);
-				}
-				auto copy_type = LogicalType::ENUM(EnumType::GetTypeName(enum_type), copy_enum_entries_vec, enum_size);
-				column.SetType(copy_type);
-			} else {
-				result->dependencies.AddDependency(*type_dependency);
-			}
-		}
 	}
 	result->dependencies.VerifyDependencies(schema.catalog, result->Base().table);
 	properties.allow_stream_result = false;

package/src/duckdb/src/planner/binder/tableref/plan_joinref.cpp

@@ -7,7 +7,6 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/operator/logical_any_join.hpp"
-#include "duckdb/planner/operator/logical_asof_join.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_cross_product.hpp"
 #include "duckdb/planner/operator/logical_dependent_join.hpp"
@@ -193,12 +192,11 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(ClientContext &con
 	} else {
 		// we successfully converted expressions into JoinConditions
 		// create a LogicalComparisonJoin
-		unique_ptr<LogicalComparisonJoin> comp_join;
+		auto logical_type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
 		if (reftype == JoinRefType::ASOF) {
-			comp_join = make_uniq<LogicalAsOfJoin>(type);
-		} else {
-			comp_join = make_uniq<LogicalComparisonJoin>(type);
+			logical_type = LogicalOperatorType::LOGICAL_ASOF_JOIN;
 		}
+		auto comp_join = make_uniq<LogicalComparisonJoin>(type, logical_type);
 		comp_join->conditions = std::move(conditions);
 		comp_join->children.push_back(std::move(left_child));
 		comp_join->children.push_back(std::move(right_child));

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

@@ -131,7 +131,6 @@ void LogicalOperator::Verify(ClientContext &context) {
 		}
 		BufferedSerializer serializer;
 		// We are serializing a query plan
-		serializer.is_query_plan = true;
 		try {
 			expressions[expr_idx]->Serialize(serializer);
 		} catch (NotImplementedException &ex) {
@@ -266,12 +265,8 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 		break;
 	case LogicalOperatorType::LOGICAL_JOIN:
 		throw InternalException("LogicalJoin deserialize not supported");
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		result = LogicalDelimJoin::Deserialize(state, reader);
-		break;
 	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-		result = LogicalAsOfJoin::Deserialize(state, reader);
-		break;
+	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 		result = LogicalComparisonJoin::Deserialize(state, reader);
 		break;

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_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/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_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;
@@ -43,6 +46,9 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
 	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;
@@ -73,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;
@@ -97,6 +106,9 @@ 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;
@@ -261,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) {
@@ -271,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);
 }
 
@@ -285,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());

package/src/duckdb/src/storage/storage_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 53;
+const uint64_t VERSION_NUMBER = 54;
 
 struct StorageVersionInfo {
 	const char *version_name;

package/src/duckdb/src/storage/table/list_column_data.cpp

@@ -89,16 +89,19 @@ idx_t ListColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t co
 	D_ASSERT(scan_count > 0);
 	validity.ScanCount(state.child_states[0], result, count);
 
-	auto data = FlatVector::GetData<uint64_t>(offset_vector);
-	auto last_entry = data[scan_count - 1];
+	UnifiedVectorFormat offsets;
+	offset_vector.ToUnifiedFormat(scan_count, offsets);
+	auto data = UnifiedVectorFormat::GetData<uint64_t>(offsets);
+	auto last_entry = data[offsets.sel->get_index(scan_count - 1)];
 
 	// shift all offsets so they are 0 at the first entry
 	auto result_data = FlatVector::GetData<list_entry_t>(result);
 	auto base_offset = state.last_offset;
 	idx_t current_offset = 0;
 	for (idx_t i = 0; i < scan_count; i++) {
+		auto offset_index = offsets.sel->get_index(i);
 		result_data[i].offset = current_offset;
-		result_data[i].length = data[i] - current_offset - base_offset;
+		result_data[i].length = data[offset_index] - current_offset - base_offset;
 		current_offset += result_data[i].length;
 	}
 

package/src/duckdb/src/storage/wal_replay.cpp

@@ -36,7 +36,6 @@ bool WriteAheadLog::Replay(AttachedDatabase &database, string &path) {
 	// first deserialize the WAL to look for a checkpoint flag
 	// if there is a checkpoint flag, we might have already flushed the contents of the WAL to disk
 	ReplayState checkpoint_state(database, *con.context, *initial_reader);
-	initial_reader->SetCatalog(checkpoint_state.catalog);
 	checkpoint_state.deserialize_only = true;
 	try {
 		while (true) {
@@ -73,7 +72,6 @@ bool WriteAheadLog::Replay(AttachedDatabase &database, string &path) {
 
 	// we need to recover from the WAL: actually set up the replay state
 	BufferedFileReader reader(FileSystem::Get(database), path.c_str(), con.context.get());
-	reader.SetCatalog(checkpoint_state.catalog);
 	ReplayState state(database, *con.context, reader);
 
 	// replay the WAL
@@ -284,7 +282,7 @@ void ReplayState::ReplayDropSchema() {
 void ReplayState::ReplayCreateType() {
 	auto info = TypeCatalogEntry::Deserialize(source);
 	info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-	catalog.CreateType(context, *info);
+	catalog.CreateType(context, info->Cast<CreateTypeInfo>());
 }
 
 void ReplayState::ReplayDropType() {

package/src/duckdb/ub_src_planner_operator.cpp

@@ -2,8 +2,6 @@
 
 #include "src/planner/operator/logical_any_join.cpp"
 
-#include "src/planner/operator/logical_asof_join.cpp"
-
 #include "src/planner/operator/logical_column_data_get.cpp"
 
 #include "src/planner/operator/logical_comparison_join.cpp"
@@ -24,8 +22,6 @@
 
 #include "src/planner/operator/logical_delim_get.cpp"
 
-#include "src/planner/operator/logical_delim_join.cpp"
-
 #include "src/planner/operator/logical_dependent_join.cpp"
 
 #include "src/planner/operator/logical_distinct.cpp"

package/src/statement.cpp

@@ -548,7 +548,6 @@ static Napi::Value TypeToObject(Napi::Env &env, const duckdb::LogicalType &type)
 		obj.Set("value", TypeToObject(env, value_type));
 	} break;
 	case duckdb::LogicalTypeId::ENUM: {
-		auto name = duckdb::EnumType::GetTypeName(type);
 		auto &values_vec = duckdb::EnumType::GetValuesInsertOrder(type);
 		auto enum_size = duckdb::EnumType::GetSize(type);
 		auto arr = Napi::Array::New(env, enum_size);
@@ -556,7 +555,6 @@ static Napi::Value TypeToObject(Napi::Env &env, const duckdb::LogicalType &type)
 			auto child_name = values_vec.GetValue(i).GetValue<duckdb::string>();
 			arr.Set(i, child_name);
 		}
-		obj.Set("name", name);
 		obj.Set("values", arr);
 	} break;
 	case duckdb::LogicalTypeId::UNION: {

package/test/columns.test.ts

@@ -48,8 +48,7 @@ describe('Column Types', function() {
               name: 'small_enum',
               type: {
                 id: 'ENUM',
-                sql_type: 'small_enum',
-                name: 'small_enum',
+                sql_type: "ENUM('DUCK_DUCK_ENUM', 'GOOSE')",
                 values: [
                   "DUCK_DUCK_ENUM",
                   "GOOSE"

package/src/duckdb/src/include/duckdb/planner/operator/logical_asof_join.hpp

@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_asof_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-
-namespace duckdb {
-
-//! LogicalAsOfJoin represents a temporal-style join with one less-than inequality.
-//! This inequality matches the greatest value on the right that satisfies the condition.
-class LogicalAsOfJoin : public LogicalComparisonJoin {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_ASOF_JOIN;
-
-public:
-	explicit LogicalAsOfJoin(JoinType type);
-
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_delim_join.hpp

@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_delim_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-
-namespace duckdb {
-
-//! LogicalDelimJoin represents a special "duplicate eliminated" join. This join type is only used for subquery
-//! flattening, and involves performing duplicate elimination on the LEFT side which is then pushed into the RIGHT side.
-class LogicalDelimJoin : public LogicalComparisonJoin {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DELIM_JOIN;
-
-public:
-	explicit LogicalDelimJoin(JoinType type);
-
-	//! The set of columns that will be duplicate eliminated from the LHS and pushed into the RHS
-	vector<unique_ptr<Expression>> duplicate_eliminated_columns;
-
-public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
-};
-
-} // namespace duckdb

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

@@ -1,14 +0,0 @@
-#include "duckdb/planner/operator/logical_asof_join.hpp"
-
-namespace duckdb {
-
-LogicalAsOfJoin::LogicalAsOfJoin(JoinType type) : LogicalComparisonJoin(type, LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-}
-
-unique_ptr<LogicalOperator> LogicalAsOfJoin::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto result = make_uniq<LogicalAsOfJoin>(JoinType::INVALID);
-	LogicalComparisonJoin::Deserialize(*result, state, reader);
-	return std::move(result);
-}
-
-} // namespace duckdb