duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

package/src/duckdb/src/catalog/catalog_entry/duck_index_entry.cpp

@@ -9,17 +9,20 @@ IndexDataTableInfo::IndexDataTableInfo(shared_ptr<DataTableInfo> info_p, const s
     : info(std::move(info_p)), index_name(index_name_p) {
 }
 
-IndexDataTableInfo::~IndexDataTableInfo() {
+void DuckIndexEntry::Rollback(CatalogEntry &) {
 	if (!info) {
 		return;
 	}
-	// FIXME: this should happen differently.
-	info->GetIndexes().RemoveIndex(index_name);
+	if (!info->info) {
+		return;
+	}
+	info->info->GetIndexes().RemoveIndex(name);
 }
 
 DuckIndexEntry::DuckIndexEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &create_info,
                                TableCatalogEntry &table_p)
     : IndexCatalogEntry(catalog, schema, create_info), initial_index_size(0) {
+
 	auto &table = table_p.Cast<DuckTableEntry>();
 	auto &storage = table.GetStorage();
 	info = make_shared_ptr<IndexDataTableInfo>(storage.GetDataTableInfo(), name);
@@ -54,7 +57,9 @@ DataTableInfo &DuckIndexEntry::GetDataTableInfo() const {
 
 void DuckIndexEntry::CommitDrop() {
 	D_ASSERT(info);
-	GetDataTableInfo().GetIndexes().CommitDrop(name);
+	auto &indexes = GetDataTableInfo().GetIndexes();
+	indexes.CommitDrop(name);
+	indexes.RemoveIndex(name);
 }
 
 } // namespace duckdb

package/src/duckdb/src/catalog/catalog_entry/duck_schema_entry.cpp

@@ -168,6 +168,9 @@ optional_ptr<CatalogEntry> DuckSchemaEntry::CreateTable(CatalogTransaction trans
 		auto &set = GetCatalogSet(CatalogType::TABLE_ENTRY);
 		info.dependencies.AddDependency(*set.GetEntry(transaction, fk_info.name));
 	}
+	for (auto &dep : info.dependencies.Set()) {
+		table->dependencies.AddDependency(dep);
+	}
 
 	auto entry = AddEntryInternal(transaction, std::move(table), info.Base().on_conflict, info.dependencies);
 	if (!entry) {
@@ -366,6 +369,11 @@ optional_ptr<CatalogEntry> DuckSchemaEntry::GetEntry(CatalogTransaction transact
 	return GetCatalogSet(type).GetEntry(transaction, name);
 }
 
+CatalogSet::EntryLookup DuckSchemaEntry::GetEntryDetailed(CatalogTransaction transaction, CatalogType type,
+                                                          const string &name) {
+	return GetCatalogSet(type).GetEntryDetailed(transaction, name);
+}
+
 SimilarCatalogEntry DuckSchemaEntry::GetSimilarEntry(CatalogTransaction transaction, CatalogType type,
                                                      const string &name) {
 	return GetCatalogSet(type).SimilarEntry(transaction, name);

package/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp

@@ -20,72 +20,22 @@
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/operator/logical_update.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
-#include "duckdb/planner/table_filter.hpp"
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/storage/table_storage_info.hpp"
 
 namespace duckdb {
 
-void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vector<PhysicalIndex> &keys,
-                       IndexConstraintType constraint_type, const IndexStorageInfo &info) {
-
-	// fetch types and create expressions for the index from the columns
-	vector<column_t> column_ids;
-	vector<unique_ptr<Expression>> unbound_expressions;
-	vector<unique_ptr<Expression>> bound_expressions;
-	idx_t key_nr = 0;
-	column_ids.reserve(keys.size());
-	for (auto &physical_key : keys) {
-		auto &column = columns.GetColumn(physical_key);
-		D_ASSERT(!column.Generated());
-		unbound_expressions.push_back(
-		    make_uniq<BoundColumnRefExpression>(column.Name(), column.Type(), ColumnBinding(0, column_ids.size())));
-
-		bound_expressions.push_back(make_uniq<BoundReferenceExpression>(column.Type(), key_nr++));
-		column_ids.push_back(column.StorageOid());
-	}
-	// create an adaptive radix tree around the expressions
-	auto art = make_uniq<ART>(info.name, constraint_type, column_ids, TableIOManager::Get(storage),
-	                          std::move(unbound_expressions), storage.db, nullptr, info);
-	if (!info.IsValid() && !info.name.empty() && !storage.IsRoot()) {
-		throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");
-	}
-	storage.AddIndex(std::move(art));
-}
-
-void AddDataTableIndex(DataTable &storage, const ColumnList &columns, vector<LogicalIndex> &keys,
-                       IndexConstraintType constraint_type, const IndexStorageInfo &info) {
-	vector<PhysicalIndex> new_keys;
-	new_keys.reserve(keys.size());
-	for (auto &logical_key : keys) {
-		new_keys.push_back(columns.LogicalToPhysical(logical_key));
-	}
-	AddDataTableIndex(storage, columns, new_keys, constraint_type, info);
-}
-
-IndexStorageInfo GetIndexInfo(const IndexConstraintType &constraint_type, const bool v1_0_0_storage,
-                              unique_ptr<CreateInfo> &create_info, const idx_t identifier) {
+IndexStorageInfo GetIndexInfo(const IndexConstraintType type, const bool v1_0_0_storage, unique_ptr<CreateInfo> &info,
+                              const idx_t id) {
 
-	auto &create_table_info = create_info->Cast<CreateTableInfo>();
-	auto constraint_name = EnumUtil::ToString(constraint_type) + "_";
-	auto name = constraint_name + create_table_info.table + "_" + to_string(identifier);
-	IndexStorageInfo info(name);
+	auto &table_info = info->Cast<CreateTableInfo>();
+	auto constraint_name = EnumUtil::ToString(type) + "_";
+	auto name = constraint_name + table_info.table + "_" + to_string(id);
+	IndexStorageInfo index_info(name);
 	if (!v1_0_0_storage) {
-		info.options.emplace("v1_0_0_storage", v1_0_0_storage);
-	}
-	return info;
-}
-
-vector<PhysicalIndex> GetUniqueConstraintKeys(const ColumnList &columns, const UniqueConstraint &constraint) {
-	vector<PhysicalIndex> indexes;
-	if (constraint.HasIndex()) {
-		indexes.push_back(columns.LogicalToPhysical(constraint.GetIndex()));
-	} else {
-		for (auto &keyname : constraint.GetColumnNames()) {
-			indexes.push_back(columns.GetColumn(keyname).Physical());
-		}
+		index_info.options.emplace("v1_0_0_storage", v1_0_0_storage);
 	}
-	return indexes;
+	return index_info;
 }
 
 DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, BoundCreateTableInfo &info,
@@ -101,28 +51,30 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 	}
 
 	// create the physical storage
-	vector<ColumnDefinition> storage_columns;
+	vector<ColumnDefinition> column_defs;
 	for (auto &col_def : columns.Physical()) {
-		storage_columns.push_back(col_def.Copy());
+		column_defs.push_back(col_def.Copy());
 	}
 	storage = make_shared_ptr<DataTable>(catalog.GetAttached(), StorageManager::Get(catalog).GetTableIOManager(&info),
-	                                     schema.name, name, std::move(storage_columns), std::move(info.data));
+	                                     schema.name, name, std::move(column_defs), std::move(info.data));
 
-	// create the unique indexes for the UNIQUE and PRIMARY KEY and FOREIGN KEY constraints
+	// Create the unique indexes for the UNIQUE, PRIMARY KEY, and FOREIGN KEY constraints.
 	idx_t indexes_idx = 0;
 	for (idx_t i = 0; i < constraints.size(); i++) {
 		auto &constraint = constraints[i];
 		if (constraint->type == ConstraintType::UNIQUE) {
-			// unique constraint: create a unique index
+
+			// UNIQUE constraint: Create a unique index.
 			auto &unique = constraint->Cast<UniqueConstraint>();
 			IndexConstraintType constraint_type = IndexConstraintType::UNIQUE;
 			if (unique.is_primary_key) {
 				constraint_type = IndexConstraintType::PRIMARY;
 			}
-			auto unique_keys = GetUniqueConstraintKeys(columns, unique);
+
+			auto column_indexes = unique.GetLogicalIndexes(columns);
 			if (info.indexes.empty()) {
-				auto index_storage_info = GetIndexInfo(constraint_type, false, info.base, i);
-				AddDataTableIndex(*storage, columns, unique_keys, constraint_type, index_storage_info);
+				auto index_info = GetIndexInfo(constraint_type, false, info.base, i);
+				storage->AddIndex(columns, column_indexes, constraint_type, index_info);
 				continue;
 			}
 
@@ -132,21 +84,27 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 				info.indexes[indexes_idx].name = name_info.name;
 			}
 
-			// now add the index
-			AddDataTableIndex(*storage, columns, unique_keys, constraint_type, info.indexes[indexes_idx++]);
+			// Now we can add the index.
+			storage->AddIndex(columns, column_indexes, constraint_type, info.indexes[indexes_idx++]);
 			continue;
 		}
 
 		if (constraint->type == ConstraintType::FOREIGN_KEY) {
-			// foreign key constraint: create a foreign key index
+			// Create a FOREIGN KEY index.
 			auto &bfk = constraint->Cast<ForeignKeyConstraint>();
 			if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
 			    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
 
+				vector<LogicalIndex> column_indexes;
+				for (const auto &physical_index : bfk.info.fk_keys) {
+					auto &col = columns.GetColumn(physical_index);
+					column_indexes.push_back(col.Logical());
+				}
+
 				if (info.indexes.empty()) {
 					auto constraint_type = IndexConstraintType::FOREIGN;
-					auto index_storage_info = GetIndexInfo(constraint_type, false, info.base, i);
-					AddDataTableIndex(*storage, columns, bfk.info.fk_keys, constraint_type, index_storage_info);
+					auto index_info = GetIndexInfo(constraint_type, false, info.base, i);
+					storage->AddIndex(columns, column_indexes, constraint_type, index_info);
 					continue;
 				}
 
@@ -156,9 +114,8 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 					info.indexes[indexes_idx].name = name_info.name;
 				}
 
-				// now add the index
-				AddDataTableIndex(*storage, columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN,
-				                  info.indexes[indexes_idx++]);
+				// Now we can add the index.
+				storage->AddIndex(columns, column_indexes, IndexConstraintType::FOREIGN, info.indexes[indexes_idx++]);
 			}
 		}
 	}
@@ -179,6 +136,10 @@ unique_ptr<BaseStatistics> DuckTableEntry::GetStatistics(ClientContext &context,
 	return storage->GetStatistics(context, column.StorageOid());
 }
 
+unique_ptr<BlockingSample> DuckTableEntry::GetSample() {
+	return storage->GetSample();
+}
+
 unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(CatalogTransaction transaction, AlterInfo &info) {
 	if (transaction.HasContext()) {
 		return AlterEntry(transaction.GetContext(), info);
@@ -258,6 +219,10 @@ unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(ClientContext &context, Alte
 		auto &drop_not_null_info = table_info.Cast<DropNotNullInfo>();
 		return DropNotNull(context, drop_not_null_info);
 	}
+	case AlterTableType::ADD_CONSTRAINT: {
+		auto &add_constraint_info = table_info.Cast<AddConstraintInfo>();
+		return AddConstraint(context, add_constraint_info);
+	}
 	default:
 		throw InternalException("Unrecognized alter table type!");
 	}
@@ -278,7 +243,7 @@ void DuckTableEntry::UndoAlter(ClientContext &context, AlterInfo &info) {
 }
 
 static void RenameExpression(ParsedExpression &expr, RenameColumnInfo &info) {
-	if (expr.type == ExpressionType::COLUMN_REF) {
+	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
 		auto &colref = expr.Cast<ColumnRefExpression>();
 		if (colref.column_names.back() == info.old_name) {
 			colref.column_names.back() = info.new_name;
@@ -565,7 +530,6 @@ unique_ptr<CatalogEntry> DuckTableEntry::SetDefault(ClientContext &context, SetD
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::SetNotNull(ClientContext &context, SetNotNullInfo &info) {
-
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->comment = comment;
 	create_info->tags = tags;
@@ -598,8 +562,9 @@ unique_ptr<CatalogEntry> DuckTableEntry::SetNotNull(ClientContext &context, SetN
 	}
 
 	// Return with new storage info. Note that we need the bound column index here.
-	auto new_storage = make_shared_ptr<DataTable>(
-	    context, *storage, make_uniq<BoundNotNullConstraint>(columns.LogicalToPhysical(LogicalIndex(not_null_idx))));
+	auto physical_columns = columns.LogicalToPhysical(LogicalIndex(not_null_idx));
+	auto bound_constraint = make_uniq<BoundNotNullConstraint>(physical_columns);
+	auto new_storage = make_shared_ptr<DataTable>(context, *storage, *bound_constraint);
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
 }
 
@@ -630,12 +595,24 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropNotNull(ClientContext &context, Dro
 unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info) {
 	auto binder = Binder::CreateBinder(context);
 	binder->BindLogicalType(info.target_type, &catalog, schema.name);
+
 	auto change_idx = GetColumnIndex(info.column_name);
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
 	create_info->comment = comment;
 	create_info->tags = tags;
 
+	// Bind the USING expression.
+	vector<LogicalIndex> bound_columns;
+	AlterBinder expr_binder(*binder, context, *this, bound_columns, info.target_type);
+	auto expression = info.expression->Copy();
+	auto bound_expression = expr_binder.Bind(expression);
+
+	// Infer the target_type from the USING expression, if not set explicitly.
+	if (info.target_type == LogicalType::UNKNOWN) {
+		info.target_type = bound_expression->return_type;
+	}
+
 	auto bound_constraints = binder->BindConstraints(constraints, name, columns);
 	for (auto &col : columns.Logical()) {
 		auto copy = col.Copy();
@@ -655,11 +632,11 @@ unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context
 		create_info->columns.AddColumn(std::move(copy));
 	}
 
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
+	for (idx_t constr_idx = 0; constr_idx < constraints.size(); constr_idx++) {
+		auto constraint = constraints[constr_idx]->Copy();
 		switch (constraint->type) {
 		case ConstraintType::CHECK: {
-			auto &bound_check = bound_constraints[i]->Cast<BoundCheckConstraint>();
+			auto &bound_check = bound_constraints[constr_idx]->Cast<BoundCheckConstraint>();
 			auto physical_index = columns.LogicalToPhysical(change_idx);
 			if (bound_check.bound_columns.find(physical_index) != bound_check.bound_columns.end()) {
 				throw BinderException("Cannot change the type of a column that has a CHECK constraint specified");
@@ -669,22 +646,21 @@ unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context
 		case ConstraintType::NOT_NULL:
 			break;
 		case ConstraintType::UNIQUE: {
-			auto &bound_unique = bound_constraints[i]->Cast<BoundUniqueConstraint>();
-			if (bound_unique.key_set.find(change_idx) != bound_unique.key_set.end()) {
+			auto &bound_unique = bound_constraints[constr_idx]->Cast<BoundUniqueConstraint>();
+			auto physical_index = columns.LogicalToPhysical(change_idx);
+			if (bound_unique.key_set.find(physical_index) != bound_unique.key_set.end()) {
 				throw BinderException(
 				    "Cannot change the type of a column that has a UNIQUE or PRIMARY KEY constraint specified");
 			}
 			break;
 		}
 		case ConstraintType::FOREIGN_KEY: {
-			auto &bfk = bound_constraints[i]->Cast<BoundForeignKeyConstraint>();
+			auto &bfk = bound_constraints[constr_idx]->Cast<BoundForeignKeyConstraint>();
 			auto key_set = bfk.pk_key_set;
 			if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
 				key_set = bfk.fk_key_set;
 			} else if (bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				for (idx_t i = 0; i < bfk.info.fk_keys.size(); i++) {
-					key_set.insert(bfk.info.fk_keys[i]);
-				}
+				key_set.insert(bfk.info.fk_keys.begin(), bfk.info.fk_keys.end());
 			}
 			if (key_set.find(columns.LogicalToPhysical(change_idx)) != key_set.end()) {
 				throw BinderException("Cannot change the type of a column that has a FOREIGN KEY constraint specified");
@@ -697,18 +673,14 @@ unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context
 		create_info->constraints.push_back(std::move(constraint));
 	}
 
-	// bind the specified expression
-	vector<LogicalIndex> bound_columns;
-	AlterBinder expr_binder(*binder, context, *this, bound_columns, info.target_type);
-	auto expression = info.expression->Copy();
-	auto bound_expression = expr_binder.Bind(expression);
 	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-	vector<column_t> storage_oids;
+
+	vector<StorageIndex> storage_oids;
 	for (idx_t i = 0; i < bound_columns.size(); i++) {
-		storage_oids.push_back(columns.LogicalToPhysical(bound_columns[i]).index);
+		storage_oids.emplace_back(columns.LogicalToPhysical(bound_columns[i]).index);
 	}
 	if (storage_oids.empty()) {
-		storage_oids.push_back(COLUMN_IDENTIFIER_ROW_ID);
+		storage_oids.emplace_back(COLUMN_IDENTIFIER_ROW_ID);
 	}
 
 	auto new_storage =
@@ -801,6 +773,84 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropForeignKeyConstraint(ClientContext
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 
+void DuckTableEntry::Rollback(CatalogEntry &prev_entry) {
+	if (prev_entry.type != CatalogType::TABLE_ENTRY) {
+		return;
+	}
+
+	// Rolls back any physical index creation.
+	// FIXME: Currently only works for PKs.
+	// FIXME: Should be changed to work for any index-based constraint.
+
+	auto &table = Cast<DuckTableEntry>();
+	auto &prev_table = prev_entry.Cast<DuckTableEntry>();
+	auto &prev_info = prev_table.GetStorage().GetDataTableInfo();
+	auto &prev_indexes = prev_info->GetIndexes();
+
+	// Find all index-based constraints that exist in rollback_table, but not in table.
+	// Then, remove them.
+
+	unordered_set<string> names;
+	for (const auto &constraint : prev_table.GetConstraints()) {
+		if (constraint->type != ConstraintType::UNIQUE) {
+			continue;
+		}
+		const auto &unique = constraint->Cast<UniqueConstraint>();
+		if (unique.is_primary_key) {
+			auto index_name = unique.GetName(prev_table.name);
+			names.insert(index_name);
+		}
+	}
+
+	for (const auto &constraint : GetConstraints()) {
+		if (constraint->type != ConstraintType::UNIQUE) {
+			continue;
+		}
+		const auto &unique = constraint->Cast<UniqueConstraint>();
+		if (!unique.IsPrimaryKey()) {
+			continue;
+		}
+		auto index_name = unique.GetName(table.name);
+		if (names.find(index_name) == names.end()) {
+			prev_indexes.RemoveIndex(index_name);
+		}
+	}
+}
+
+unique_ptr<CatalogEntry> DuckTableEntry::AddConstraint(ClientContext &context, AddConstraintInfo &info) {
+	auto create_info = make_uniq<CreateTableInfo>(schema, name);
+	create_info->comment = comment;
+
+	// Copy all columns and constraints to the modified table.
+	create_info->columns = columns.Copy();
+	for (const auto &constraint : constraints) {
+		create_info->constraints.push_back(constraint->Copy());
+	}
+
+	if (info.constraint->type == ConstraintType::UNIQUE) {
+		const auto &unique = info.constraint->Cast<UniqueConstraint>();
+		const auto existing_pk = GetPrimaryKey();
+
+		if (unique.is_primary_key && existing_pk) {
+			auto existing_name = existing_pk->ToString();
+			throw CatalogException("table \"%s\" can have only one primary key: %s", name, existing_name);
+		}
+		create_info->constraints.push_back(info.constraint->Copy());
+
+	} else {
+		throw InternalException("unsupported constraint type in ALTER TABLE statement");
+	}
+
+	// We create a physical table with a new constraint and a new unique index.
+	const auto binder = Binder::CreateBinder(context);
+	const auto bound_constraint = binder->BindConstraint(*info.constraint, create_info->table, create_info->columns);
+	const auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
+
+	auto new_storage = make_shared_ptr<DataTable>(context, *storage, *bound_constraint);
+	auto new_entry = make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
+	return std::move(new_entry);
+}
+
 unique_ptr<CatalogEntry> DuckTableEntry::Copy(ClientContext &context) const {
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->comment = comment;

package/src/duckdb/src/catalog/catalog_entry/scalar_function_catalog_entry.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
+#include "duckdb/common/vector.hpp"
 #include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp"
 
 namespace duckdb {
@@ -8,7 +9,7 @@ ScalarFunctionCatalogEntry::ScalarFunctionCatalogEntry(Catalog &catalog, SchemaC
     : FunctionEntry(CatalogType::SCALAR_FUNCTION_ENTRY, catalog, schema, info), functions(info.functions) {
 }
 
-unique_ptr<CatalogEntry> ScalarFunctionCatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
+unique_ptr<CatalogEntry> ScalarFunctionCatalogEntry::AlterEntry(CatalogTransaction transaction, AlterInfo &info) {
 	if (info.type != AlterType::ALTER_SCALAR_FUNCTION) {
 		throw InternalException("Attempting to alter ScalarFunctionCatalogEntry with unsupported alter type");
 	}
@@ -20,10 +21,15 @@ unique_ptr<CatalogEntry> ScalarFunctionCatalogEntry::AlterEntry(ClientContext &c
 	auto &add_overloads = function_info.Cast<AddScalarFunctionOverloadInfo>();
 
 	ScalarFunctionSet new_set = functions;
-	if (!new_set.MergeFunctionSet(add_overloads.new_overloads)) {
-		throw BinderException("Failed to add new function overloads to function \"%s\": function already exists", name);
+	if (!new_set.MergeFunctionSet(add_overloads.new_overloads->functions, true)) {
+		throw BinderException(
+		    "Failed to add new function overloads to function \"%s\": function overload already exists", name);
 	}
 	CreateScalarFunctionInfo new_info(std::move(new_set));
+	new_info.internal = internal;
+	new_info.descriptions = descriptions;
+	new_info.descriptions.insert(new_info.descriptions.end(), add_overloads.new_overloads->descriptions.begin(),
+	                             add_overloads.new_overloads->descriptions.end());
 	return make_uniq<ScalarFunctionCatalogEntry>(catalog, schema, new_info);
 }
 

package/src/duckdb/src/catalog/catalog_entry/schema_catalog_entry.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/default/default_schemas.hpp"
 
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/algorithm.hpp"
@@ -39,6 +40,20 @@ SimilarCatalogEntry SchemaCatalogEntry::GetSimilarEntry(CatalogTransaction trans
 	return result;
 }
 
+//! This should not be used, it's only implemented to not put the burden of implementing it on every derived class of
+//! SchemaCatalogEntry
+CatalogSet::EntryLookup SchemaCatalogEntry::GetEntryDetailed(CatalogTransaction transaction, CatalogType type,
+                                                             const string &name) {
+	CatalogSet::EntryLookup result;
+	result.result = GetEntry(transaction, type, name);
+	if (!result.result) {
+		result.reason = CatalogSet::EntryLookup::FailureReason::DELETED;
+	} else {
+		result.reason = CatalogSet::EntryLookup::FailureReason::SUCCESS;
+	}
+	return result;
+}
+
 unique_ptr<CreateInfo> SchemaCatalogEntry::GetInfo() const {
 	auto result = make_uniq<CreateSchemaInfo>();
 	result->schema = name;

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -43,6 +43,10 @@ LogicalIndex TableCatalogEntry::GetColumnIndex(string &column_name, bool if_exis
 	return entry;
 }
 
+unique_ptr<BlockingSample> TableCatalogEntry::GetSample() {
+	return nullptr;
+}
+
 bool TableCatalogEntry::ColumnExists(const string &name) const {
 	return columns.ColumnExists(name);
 }
@@ -144,7 +148,7 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<u
 			if (column_type.id() != LogicalTypeId::ANY) {
 				// We artificially add a cast if the type is specified, need to strip it
 				auto &expr = generated_expression.get();
-				D_ASSERT(expr.type == ExpressionType::OPERATOR_CAST);
+				D_ASSERT(expr.GetExpressionType() == ExpressionType::OPERATOR_CAST);
 				auto &cast_expr = expr.Cast<CastExpression>();
 				D_ASSERT(cast_expr.cast_type.id() == column_type.id());
 				generated_expression = *cast_expr.child;
@@ -176,6 +180,24 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<u
 	return ss.str();
 }
 
+string TableCatalogEntry::ColumnNamesToSQL(const ColumnList &columns) {
+	if (columns.empty()) {
+		return "";
+	}
+
+	std::stringstream ss;
+	ss << "(";
+
+	for (auto &column : columns.Logical()) {
+		if (column.Oid() > 0) {
+			ss << ", ";
+		}
+		ss << KeywordHelper::WriteOptionallyQuoted(column.Name()) << " ";
+	}
+	ss << ")";
+	return ss.str();
+}
+
 string TableCatalogEntry::ToSQL() const {
 	auto create_info = GetInfo();
 	return create_info->ToString();
@@ -233,28 +255,6 @@ static void BindExtraColumns(TableCatalogEntry &table, LogicalGet &get, LogicalP
 	}
 }
 
-static bool TypeSupportsRegularUpdate(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::ARRAY:
-	case LogicalTypeId::MAP:
-	case LogicalTypeId::UNION:
-		// lists and maps and unions don't support updates directly
-		return false;
-	case LogicalTypeId::STRUCT: {
-		auto &child_types = StructType::GetChildTypes(type);
-		for (auto &entry : child_types) {
-			if (!TypeSupportsRegularUpdate(entry.second)) {
-				return false;
-			}
-		}
-		return true;
-	}
-	default:
-		return true;
-	}
-}
-
 vector<ColumnSegmentInfo> TableCatalogEntry::GetColumnSegmentInfo() {
 	return {};
 }
@@ -299,7 +299,7 @@ void TableCatalogEntry::BindUpdateConstraints(Binder &binder, LogicalGet &get, L
 	// we also convert any updates on LIST columns into delete + insert
 	for (auto &col_index : update.columns) {
 		auto &column = GetColumns().GetColumn(col_index);
-		if (!TypeSupportsRegularUpdate(column.Type())) {
+		if (!column.Type().SupportsRegularUpdate()) {
 			update.update_is_del_and_insert = true;
 			break;
 		}
@@ -316,4 +316,20 @@ void TableCatalogEntry::BindUpdateConstraints(Binder &binder, LogicalGet &get, L
 	}
 }
 
+optional_ptr<Constraint> TableCatalogEntry::GetPrimaryKey() const {
+	for (const auto &constraint : GetConstraints()) {
+		if (constraint->type == ConstraintType::UNIQUE) {
+			auto &unique = constraint->Cast<UniqueConstraint>();
+			if (unique.IsPrimaryKey()) {
+				return &unique;
+			}
+		}
+	}
+	return nullptr;
+}
+
+bool TableCatalogEntry::HasPrimaryKey() const {
+	return GetPrimaryKey() != nullptr;
+}
+
 } // namespace duckdb

package/src/duckdb/src/catalog/catalog_entry/table_function_catalog_entry.cpp

@@ -9,7 +9,7 @@ TableFunctionCatalogEntry::TableFunctionCatalogEntry(Catalog &catalog, SchemaCat
 	D_ASSERT(this->functions.Size() > 0);
 }
 
-unique_ptr<CatalogEntry> TableFunctionCatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
+unique_ptr<CatalogEntry> TableFunctionCatalogEntry::AlterEntry(CatalogTransaction transaction, AlterInfo &info) {
 	if (info.type != AlterType::ALTER_TABLE_FUNCTION) {
 		throw InternalException("Attempting to alter TableFunctionCatalogEntry with unsupported alter type");
 	}

package/src/duckdb/src/catalog/catalog_entry/type_catalog_entry.cpp

@@ -11,7 +11,7 @@ namespace duckdb {
 
 TypeCatalogEntry::TypeCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTypeInfo &info)
     : StandardEntry(CatalogType::TYPE_ENTRY, schema, catalog, info.name), user_type(info.type),
-      bind_modifiers(info.bind_modifiers) {
+      bind_function(info.bind_function) {
 	this->temporary = info.temporary;
 	this->internal = info.internal;
 	this->dependencies = info.dependencies;
@@ -35,7 +35,7 @@ unique_ptr<CreateInfo> TypeCatalogEntry::GetInfo() const {
 	result->dependencies = dependencies;
 	result->comment = comment;
 	result->tags = tags;
-	result->bind_modifiers = bind_modifiers;
+	result->bind_function = bind_function;
 	return std::move(result);
 }
 

package/src/duckdb/src/catalog/catalog_entry.cpp

@@ -109,6 +109,9 @@ unique_ptr<CreateInfo> CatalogEntry::Deserialize(Deserializer &deserializer) {
 void CatalogEntry::Verify(Catalog &catalog_p) {
 }
 
+void CatalogEntry::Rollback(CatalogEntry &prev_entry) {
+}
+
 InCatalogEntry::InCatalogEntry(CatalogType type, Catalog &catalog, string name)
     : CatalogEntry(type, catalog, std::move(name)), catalog(catalog) {
 }