duckdb 0.7.2-dev2430.0 → 0.7.2-dev2552.0

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

@@ -50,7 +50,8 @@ void FindForeignKeyInformation(CatalogEntry &entry, AlterForeignKeyType alter_fk
 		}
 		auto &fk = cond->Cast<ForeignKeyConstraint>();
 		if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-			AlterEntryData alter_data(entry.catalog->GetName(), fk.info.schema, fk.info.table, false);
+			AlterEntryData alter_data(entry.ParentCatalog().GetName(), fk.info.schema, fk.info.table,
+			                          OnEntryNotFound::THROW_EXCEPTION);
 			fk_arrays.push_back(make_uniq<AlterForeignKeyInfo>(std::move(alter_data), entry.name, fk.pk_columns,
 			                                                   fk.fk_columns, fk.info.pk_keys, fk.info.fk_keys,
 			                                                   alter_fk_type));
@@ -62,16 +63,18 @@ void FindForeignKeyInformation(CatalogEntry &entry, AlterForeignKeyType alter_fk
 	}
 }
 
-DuckSchemaEntry::DuckSchemaEntry(Catalog *catalog, string name_p, bool is_internal)
+DuckSchemaEntry::DuckSchemaEntry(Catalog &catalog, string name_p, bool is_internal)
     : SchemaCatalogEntry(catalog, std::move(name_p), is_internal),
-      tables(*catalog, make_uniq<DefaultViewGenerator>(*catalog, *this)), indexes(*catalog), table_functions(*catalog),
-      copy_functions(*catalog), pragma_functions(*catalog),
-      functions(*catalog, make_uniq<DefaultFunctionGenerator>(*catalog, *this)), sequences(*catalog),
-      collations(*catalog), types(*catalog, make_uniq<DefaultTypeGenerator>(*catalog, *this)) {
+      tables(catalog, make_uniq<DefaultViewGenerator>(catalog, *this)), indexes(catalog), table_functions(catalog),
+      copy_functions(catalog), pragma_functions(catalog),
+      functions(catalog, make_uniq<DefaultFunctionGenerator>(catalog, *this)), sequences(catalog), collations(catalog),
+      types(catalog, make_uniq<DefaultTypeGenerator>(catalog, *this)) {
 }
 
-CatalogEntry *DuckSchemaEntry::AddEntryInternal(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
-                                                OnCreateConflict on_conflict, DependencyList dependencies) {
+optional_ptr<CatalogEntry> DuckSchemaEntry::AddEntryInternal(CatalogTransaction transaction,
+                                                             unique_ptr<StandardEntry> entry,
+                                                             OnCreateConflict on_conflict,
+                                                             DependencyList dependencies) {
 	auto entry_name = entry->name;
 	auto entry_type = entry->type;
 	auto result = entry.get();
@@ -102,12 +105,12 @@ CatalogEntry *DuckSchemaEntry::AddEntryInternal(CatalogTransaction transaction,
 	return result;
 }
 
-CatalogEntry *DuckSchemaEntry::CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info) {
-	auto table = make_uniq<DuckTableEntry>(catalog, this, info);
+optional_ptr<CatalogEntry> DuckSchemaEntry::CreateTable(CatalogTransaction transaction, BoundCreateTableInfo &info) {
+	auto table = make_uniq<DuckTableEntry>(catalog, *this, info);
 	auto &storage = table->GetStorage();
 	storage.info->cardinality = storage.GetTotalRows();
 
-	CatalogEntry *entry = AddEntryInternal(transaction, std::move(table), info->Base().on_conflict, info->dependencies);
+	auto entry = AddEntryInternal(transaction, std::move(table), info.Base().on_conflict, info.dependencies);
 	if (!entry) {
 		return nullptr;
 	}
@@ -117,122 +120,126 @@ CatalogEntry *DuckSchemaEntry::CreateTable(CatalogTransaction transaction, Bound
 	FindForeignKeyInformation(*entry, AlterForeignKeyType::AFT_ADD, fk_arrays);
 	for (idx_t i = 0; i < fk_arrays.size(); i++) {
 		// alter primary key table
-		AlterForeignKeyInfo *fk_info = fk_arrays[i].get();
-		catalog->Alter(transaction.GetContext(), fk_info);
+		auto &fk_info = *fk_arrays[i];
+		catalog.Alter(transaction.GetContext(), fk_info);
 
 		// make a dependency between this table and referenced table
 		auto &set = GetCatalogSet(CatalogType::TABLE_ENTRY);
-		info->dependencies.AddDependency(*set.GetEntry(transaction, fk_info->name));
+		info.dependencies.AddDependency(*set.GetEntry(transaction, fk_info.name));
 	}
 	return entry;
 }
 
-CatalogEntry *DuckSchemaEntry::CreateFunction(CatalogTransaction transaction, CreateFunctionInfo *info) {
-	if (info->on_conflict == OnCreateConflict::ALTER_ON_CONFLICT) {
+optional_ptr<CatalogEntry> DuckSchemaEntry::CreateFunction(CatalogTransaction transaction, CreateFunctionInfo &info) {
+	if (info.on_conflict == OnCreateConflict::ALTER_ON_CONFLICT) {
 		// check if the original entry exists
-		auto &catalog_set = GetCatalogSet(info->type);
-		auto current_entry = catalog_set.GetEntry(transaction, info->name);
+		auto &catalog_set = GetCatalogSet(info.type);
+		auto current_entry = catalog_set.GetEntry(transaction, info.name);
 		if (current_entry) {
 			// the current entry exists - alter it instead
-			auto alter_info = info->GetAlterInfo();
-			Alter(transaction.GetContext(), alter_info.get());
+			auto alter_info = info.GetAlterInfo();
+			Alter(transaction.GetContext(), *alter_info);
 			return nullptr;
 		}
 	}
 	unique_ptr<StandardEntry> function;
-	switch (info->type) {
+	switch (info.type) {
 	case CatalogType::SCALAR_FUNCTION_ENTRY:
-		function =
-		    make_uniq_base<StandardEntry, ScalarFunctionCatalogEntry>(catalog, this, (CreateScalarFunctionInfo *)info);
+		function = make_uniq_base<StandardEntry, ScalarFunctionCatalogEntry>(catalog, *this,
+		                                                                     info.Cast<CreateScalarFunctionInfo>());
 		break;
 	case CatalogType::TABLE_FUNCTION_ENTRY:
-		function =
-		    make_uniq_base<StandardEntry, TableFunctionCatalogEntry>(catalog, this, (CreateTableFunctionInfo *)info);
+		function = make_uniq_base<StandardEntry, TableFunctionCatalogEntry>(catalog, *this,
+		                                                                    info.Cast<CreateTableFunctionInfo>());
 		break;
 	case CatalogType::MACRO_ENTRY:
 		// create a macro function
-		function = make_uniq_base<StandardEntry, ScalarMacroCatalogEntry>(catalog, this, (CreateMacroInfo *)info);
+		function = make_uniq_base<StandardEntry, ScalarMacroCatalogEntry>(catalog, *this, info.Cast<CreateMacroInfo>());
 		break;
 
 	case CatalogType::TABLE_MACRO_ENTRY:
 		// create a macro table function
-		function = make_uniq_base<StandardEntry, TableMacroCatalogEntry>(catalog, this, (CreateMacroInfo *)info);
+		function = make_uniq_base<StandardEntry, TableMacroCatalogEntry>(catalog, *this, info.Cast<CreateMacroInfo>());
 		break;
 	case CatalogType::AGGREGATE_FUNCTION_ENTRY:
-		D_ASSERT(info->type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
+		D_ASSERT(info.type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
 		// create an aggregate function
-		function = make_uniq_base<StandardEntry, AggregateFunctionCatalogEntry>(catalog, this,
-		                                                                        (CreateAggregateFunctionInfo *)info);
+		function = make_uniq_base<StandardEntry, AggregateFunctionCatalogEntry>(
+		    catalog, *this, info.Cast<CreateAggregateFunctionInfo>());
 		break;
 	default:
-		throw InternalException("Unknown function type \"%s\"", CatalogTypeToString(info->type));
+		throw InternalException("Unknown function type \"%s\"", CatalogTypeToString(info.type));
 	}
-	function->internal = info->internal;
-	return AddEntry(transaction, std::move(function), info->on_conflict);
+	function->internal = info.internal;
+	return AddEntry(transaction, std::move(function), info.on_conflict);
 }
 
-CatalogEntry *DuckSchemaEntry::AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
-                                        OnCreateConflict on_conflict) {
+optional_ptr<CatalogEntry> DuckSchemaEntry::AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
+                                                     OnCreateConflict on_conflict) {
 	DependencyList dependencies;
 	return AddEntryInternal(transaction, std::move(entry), on_conflict, dependencies);
 }
 
-CatalogEntry *DuckSchemaEntry::CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info) {
-	auto sequence = make_uniq<SequenceCatalogEntry>(catalog, this, info);
-	return AddEntry(transaction, std::move(sequence), info->on_conflict);
+optional_ptr<CatalogEntry> DuckSchemaEntry::CreateSequence(CatalogTransaction transaction, CreateSequenceInfo &info) {
+	auto sequence = make_uniq<SequenceCatalogEntry>(catalog, *this, info);
+	return AddEntry(transaction, std::move(sequence), info.on_conflict);
 }
 
-CatalogEntry *DuckSchemaEntry::CreateType(CatalogTransaction transaction, CreateTypeInfo *info) {
-	auto type_entry = make_uniq<TypeCatalogEntry>(catalog, this, info);
-	return AddEntry(transaction, std::move(type_entry), info->on_conflict);
+optional_ptr<CatalogEntry> DuckSchemaEntry::CreateType(CatalogTransaction transaction, CreateTypeInfo &info) {
+	auto type_entry = make_uniq<TypeCatalogEntry>(catalog, *this, info);
+	return AddEntry(transaction, std::move(type_entry), info.on_conflict);
 }
 
-CatalogEntry *DuckSchemaEntry::CreateView(CatalogTransaction transaction, CreateViewInfo *info) {
-	auto view = make_uniq<ViewCatalogEntry>(catalog, this, info);
-	return AddEntry(transaction, std::move(view), info->on_conflict);
+optional_ptr<CatalogEntry> DuckSchemaEntry::CreateView(CatalogTransaction transaction, CreateViewInfo &info) {
+	auto view = make_uniq<ViewCatalogEntry>(catalog, *this, info);
+	return AddEntry(transaction, std::move(view), info.on_conflict);
 }
 
-CatalogEntry *DuckSchemaEntry::CreateIndex(ClientContext &context, CreateIndexInfo *info, TableCatalogEntry *table) {
+optional_ptr<CatalogEntry> DuckSchemaEntry::CreateIndex(ClientContext &context, CreateIndexInfo &info,
+                                                        TableCatalogEntry &table) {
 	DependencyList dependencies;
-	dependencies.AddDependency(*table);
-	auto index = make_uniq<DuckIndexEntry>(catalog, this, info);
-	return AddEntryInternal(GetCatalogTransaction(context), std::move(index), info->on_conflict, dependencies);
+	dependencies.AddDependency(table);
+	auto index = make_uniq<DuckIndexEntry>(catalog, *this, info);
+	return AddEntryInternal(GetCatalogTransaction(context), std::move(index), info.on_conflict, dependencies);
 }
 
-CatalogEntry *DuckSchemaEntry::CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info) {
-	auto collation = make_uniq<CollateCatalogEntry>(catalog, this, info);
-	collation->internal = info->internal;
-	return AddEntry(transaction, std::move(collation), info->on_conflict);
+optional_ptr<CatalogEntry> DuckSchemaEntry::CreateCollation(CatalogTransaction transaction, CreateCollationInfo &info) {
+	auto collation = make_uniq<CollateCatalogEntry>(catalog, *this, info);
+	collation->internal = info.internal;
+	return AddEntry(transaction, std::move(collation), info.on_conflict);
 }
 
-CatalogEntry *DuckSchemaEntry::CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info) {
-	auto table_function = make_uniq<TableFunctionCatalogEntry>(catalog, this, info);
-	table_function->internal = info->internal;
-	return AddEntry(transaction, std::move(table_function), info->on_conflict);
+optional_ptr<CatalogEntry> DuckSchemaEntry::CreateTableFunction(CatalogTransaction transaction,
+                                                                CreateTableFunctionInfo &info) {
+	auto table_function = make_uniq<TableFunctionCatalogEntry>(catalog, *this, info);
+	table_function->internal = info.internal;
+	return AddEntry(transaction, std::move(table_function), info.on_conflict);
 }
 
-CatalogEntry *DuckSchemaEntry::CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info) {
-	auto copy_function = make_uniq<CopyFunctionCatalogEntry>(catalog, this, info);
-	copy_function->internal = info->internal;
-	return AddEntry(transaction, std::move(copy_function), info->on_conflict);
+optional_ptr<CatalogEntry> DuckSchemaEntry::CreateCopyFunction(CatalogTransaction transaction,
+                                                               CreateCopyFunctionInfo &info) {
+	auto copy_function = make_uniq<CopyFunctionCatalogEntry>(catalog, *this, info);
+	copy_function->internal = info.internal;
+	return AddEntry(transaction, std::move(copy_function), info.on_conflict);
 }
 
-CatalogEntry *DuckSchemaEntry::CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info) {
-	auto pragma_function = make_uniq<PragmaFunctionCatalogEntry>(catalog, this, info);
-	pragma_function->internal = info->internal;
-	return AddEntry(transaction, std::move(pragma_function), info->on_conflict);
+optional_ptr<CatalogEntry> DuckSchemaEntry::CreatePragmaFunction(CatalogTransaction transaction,
+                                                                 CreatePragmaFunctionInfo &info) {
+	auto pragma_function = make_uniq<PragmaFunctionCatalogEntry>(catalog, *this, info);
+	pragma_function->internal = info.internal;
+	return AddEntry(transaction, std::move(pragma_function), info.on_conflict);
 }
 
-void DuckSchemaEntry::Alter(ClientContext &context, AlterInfo *info) {
-	CatalogType type = info->GetCatalogType();
+void DuckSchemaEntry::Alter(ClientContext &context, AlterInfo &info) {
+	CatalogType type = info.GetCatalogType();
 	auto &set = GetCatalogSet(type);
 	auto transaction = GetCatalogTransaction(context);
-	if (info->type == AlterType::CHANGE_OWNERSHIP) {
-		if (!set.AlterOwnership(transaction, (ChangeOwnershipInfo *)info)) {
+	if (info.type == AlterType::CHANGE_OWNERSHIP) {
+		if (!set.AlterOwnership(transaction, info.Cast<ChangeOwnershipInfo>())) {
 			throw CatalogException("Couldn't change ownership!");
 		}
 	} else {
-		string name = info->name;
+		string name = info.name;
 		if (!set.AlterEntry(transaction, name, info)) {
 			throw CatalogException("Entry with name \"%s\" does not exist!", name);
 		}
@@ -240,46 +247,47 @@ void DuckSchemaEntry::Alter(ClientContext &context, AlterInfo *info) {
 }
 
 void DuckSchemaEntry::Scan(ClientContext &context, CatalogType type,
-                           const std::function<void(CatalogEntry *)> &callback) {
+                           const std::function<void(CatalogEntry &)> &callback) {
 	auto &set = GetCatalogSet(type);
 	set.Scan(GetCatalogTransaction(context), callback);
 }
 
-void DuckSchemaEntry::Scan(CatalogType type, const std::function<void(CatalogEntry *)> &callback) {
+void DuckSchemaEntry::Scan(CatalogType type, const std::function<void(CatalogEntry &)> &callback) {
 	auto &set = GetCatalogSet(type);
 	set.Scan(callback);
 }
 
-void DuckSchemaEntry::DropEntry(ClientContext &context, DropInfo *info) {
-	auto &set = GetCatalogSet(info->type);
+void DuckSchemaEntry::DropEntry(ClientContext &context, DropInfo &info) {
+	auto &set = GetCatalogSet(info.type);
 
 	// first find the entry
 	auto transaction = GetCatalogTransaction(context);
-	auto existing_entry = set.GetEntry(transaction, info->name);
+	auto existing_entry = set.GetEntry(transaction, info.name);
 	if (!existing_entry) {
-		throw InternalException("Failed to drop entry \"%s\" - entry could not be found", info->name);
+		throw InternalException("Failed to drop entry \"%s\" - entry could not be found", info.name);
 	}
-	if (existing_entry->type != info->type) {
-		throw CatalogException("Existing object %s is of type %s, trying to replace with type %s", info->name,
-		                       CatalogTypeToString(existing_entry->type), CatalogTypeToString(info->type));
+	if (existing_entry->type != info.type) {
+		throw CatalogException("Existing object %s is of type %s, trying to replace with type %s", info.name,
+		                       CatalogTypeToString(existing_entry->type), CatalogTypeToString(info.type));
 	}
 
 	// if there is a foreign key constraint, get that information
 	vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
 	FindForeignKeyInformation(*existing_entry, AlterForeignKeyType::AFT_DELETE, fk_arrays);
 
-	if (!set.DropEntry(transaction, info->name, info->cascade, info->allow_drop_internal)) {
+	if (!set.DropEntry(transaction, info.name, info.cascade, info.allow_drop_internal)) {
 		throw InternalException("Could not drop element because of an internal error");
 	}
 
 	// remove the foreign key constraint in main key table if main key table's name is valid
 	for (idx_t i = 0; i < fk_arrays.size(); i++) {
 		// alter primary key table
-		catalog->Alter(context, fk_arrays[i].get());
+		catalog.Alter(context, *fk_arrays[i]);
 	}
 }
 
-CatalogEntry *DuckSchemaEntry::GetEntry(CatalogTransaction transaction, CatalogType type, const string &name) {
+optional_ptr<CatalogEntry> DuckSchemaEntry::GetEntry(CatalogTransaction transaction, CatalogType type,
+                                                     const string &name) {
 	return GetCatalogSet(type).GetEntry(transaction, name);
 }
 
@@ -318,7 +326,7 @@ CatalogSet &DuckSchemaEntry::GetCatalogSet(CatalogType type) {
 }
 
 void DuckSchemaEntry::Verify(Catalog &catalog) {
-	CatalogEntry::Verify(catalog);
+	InCatalogEntry::Verify(catalog);
 
 	tables.Verify(catalog);
 	indexes.Verify(catalog);

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

@@ -19,7 +19,7 @@
 
 namespace duckdb {
 
-void AddDataTableIndex(DataTable *storage, const ColumnList &columns, const vector<PhysicalIndex> &keys,
+void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vector<PhysicalIndex> &keys,
                        IndexConstraintType constraint_type, BlockPointer *index_block = nullptr) {
 	// fetch types and create expressions for the index from the columns
 	vector<column_t> column_ids;
@@ -39,19 +39,19 @@ void AddDataTableIndex(DataTable *storage, const ColumnList &columns, const vect
 	unique_ptr<ART> art;
 	// create an adaptive radix tree around the expressions
 	if (index_block) {
-		art = make_uniq<ART>(column_ids, TableIOManager::Get(*storage), std::move(unbound_expressions), constraint_type,
-		                     storage->db, true, index_block->block_id, index_block->offset);
+		art = make_uniq<ART>(column_ids, TableIOManager::Get(storage), std::move(unbound_expressions), constraint_type,
+		                     storage.db, true, index_block->block_id, index_block->offset);
 	} else {
-		art = make_uniq<ART>(column_ids, TableIOManager::Get(*storage), std::move(unbound_expressions), constraint_type,
-		                     storage->db, true);
-		if (!storage->IsRoot()) {
+		art = make_uniq<ART>(column_ids, TableIOManager::Get(storage), std::move(unbound_expressions), constraint_type,
+		                     storage.db, true);
+		if (!storage.IsRoot()) {
 			throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");
 		}
 	}
-	storage->info->indexes.AddIndex(std::move(art));
+	storage.info->indexes.AddIndex(std::move(art));
 }
 
-void AddDataTableIndex(DataTable *storage, const ColumnList &columns, vector<LogicalIndex> &keys,
+void AddDataTableIndex(DataTable &storage, const ColumnList &columns, vector<LogicalIndex> &keys,
                        IndexConstraintType constraint_type, BlockPointer *index_block = nullptr) {
 	vector<PhysicalIndex> new_keys;
 	new_keys.reserve(keys.size());
@@ -61,19 +61,19 @@ void AddDataTableIndex(DataTable *storage, const ColumnList &columns, vector<Log
 	AddDataTableIndex(storage, columns, new_keys, constraint_type, index_block);
 }
 
-DuckTableEntry::DuckTableEntry(Catalog *catalog, SchemaCatalogEntry *schema, BoundCreateTableInfo *info,
+DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, BoundCreateTableInfo &info,
                                std::shared_ptr<DataTable> inherited_storage)
-    : TableCatalogEntry(catalog, schema, info->Base()), storage(std::move(inherited_storage)),
-      bound_constraints(std::move(info->bound_constraints)),
-      column_dependency_manager(std::move(info->column_dependency_manager)) {
+    : TableCatalogEntry(catalog, schema, info.Base()), storage(std::move(inherited_storage)),
+      bound_constraints(std::move(info.bound_constraints)),
+      column_dependency_manager(std::move(info.column_dependency_manager)) {
 	if (!storage) {
 		// create the physical storage
 		vector<ColumnDefinition> storage_columns;
 		for (auto &col_def : columns.Physical()) {
 			storage_columns.push_back(col_def.Copy());
 		}
-		storage = make_shared<DataTable>(catalog->GetAttached(), StorageManager::Get(*catalog).GetTableIOManager(info),
-		                                 schema->name, name, std::move(storage_columns), std::move(info->data));
+		storage = make_shared<DataTable>(catalog.GetAttached(), StorageManager::Get(catalog).GetTableIOManager(&info),
+		                                 schema.name, name, std::move(storage_columns), std::move(info.data));
 
 		// create the unique indexes for the UNIQUE and PRIMARY KEY and FOREIGN KEY constraints
 		idx_t indexes_idx = 0;
@@ -86,22 +86,21 @@ DuckTableEntry::DuckTableEntry(Catalog *catalog, SchemaCatalogEntry *schema, Bou
 				if (unique.is_primary_key) {
 					constraint_type = IndexConstraintType::PRIMARY;
 				}
-				if (info->indexes.empty()) {
-					AddDataTableIndex(storage.get(), columns, unique.keys, constraint_type);
+				if (info.indexes.empty()) {
+					AddDataTableIndex(*storage, columns, unique.keys, constraint_type);
 				} else {
-					AddDataTableIndex(storage.get(), columns, unique.keys, constraint_type,
-					                  &info->indexes[indexes_idx++]);
+					AddDataTableIndex(*storage, columns, unique.keys, constraint_type, &info.indexes[indexes_idx++]);
 				}
 			} else if (constraint->type == ConstraintType::FOREIGN_KEY) {
 				// foreign key constraint: create a foreign key index
 				auto &bfk = constraint->Cast<BoundForeignKeyConstraint>();
 				if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
 				    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-					if (info->indexes.empty()) {
-						AddDataTableIndex(storage.get(), columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN);
+					if (info.indexes.empty()) {
+						AddDataTableIndex(*storage, columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN);
 					} else {
-						AddDataTableIndex(storage.get(), columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN,
-						                  &info->indexes[indexes_idx++]);
+						AddDataTableIndex(*storage, columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN,
+						                  &info.indexes[indexes_idx++]);
 					}
 				}
 			}
@@ -120,66 +119,66 @@ unique_ptr<BaseStatistics> DuckTableEntry::GetStatistics(ClientContext &context,
 	return storage->GetStatistics(context, column.StorageOid());
 }
 
-unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(ClientContext &context, AlterInfo *info) {
+unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
 	D_ASSERT(!internal);
-	if (info->type != AlterType::ALTER_TABLE) {
+	if (info.type != AlterType::ALTER_TABLE) {
 		throw CatalogException("Can only modify table with ALTER TABLE statement");
 	}
-	auto table_info = (AlterTableInfo *)info;
-	switch (table_info->alter_table_type) {
+	auto &table_info = info.Cast<AlterTableInfo>();
+	switch (table_info.alter_table_type) {
 	case AlterTableType::RENAME_COLUMN: {
-		auto rename_info = (RenameColumnInfo *)table_info;
-		return RenameColumn(context, *rename_info);
+		auto &rename_info = table_info.Cast<RenameColumnInfo>();
+		return RenameColumn(context, rename_info);
 	}
 	case AlterTableType::RENAME_TABLE: {
-		auto rename_info = (RenameTableInfo *)table_info;
+		auto &rename_info = table_info.Cast<RenameTableInfo>();
 		auto copied_table = Copy(context);
-		copied_table->name = rename_info->new_table_name;
-		storage->info->table = rename_info->new_table_name;
+		copied_table->name = rename_info.new_table_name;
+		storage->info->table = rename_info.new_table_name;
 		return copied_table;
 	}
 	case AlterTableType::ADD_COLUMN: {
-		auto add_info = (AddColumnInfo *)table_info;
-		return AddColumn(context, *add_info);
+		auto &add_info = table_info.Cast<AddColumnInfo>();
+		return AddColumn(context, add_info);
 	}
 	case AlterTableType::REMOVE_COLUMN: {
-		auto remove_info = (RemoveColumnInfo *)table_info;
-		return RemoveColumn(context, *remove_info);
+		auto &remove_info = table_info.Cast<RemoveColumnInfo>();
+		return RemoveColumn(context, remove_info);
 	}
 	case AlterTableType::SET_DEFAULT: {
-		auto set_default_info = (SetDefaultInfo *)table_info;
-		return SetDefault(context, *set_default_info);
+		auto &set_default_info = table_info.Cast<SetDefaultInfo>();
+		return SetDefault(context, set_default_info);
 	}
 	case AlterTableType::ALTER_COLUMN_TYPE: {
-		auto change_type_info = (ChangeColumnTypeInfo *)table_info;
-		return ChangeColumnType(context, *change_type_info);
+		auto &change_type_info = table_info.Cast<ChangeColumnTypeInfo>();
+		return ChangeColumnType(context, change_type_info);
 	}
 	case AlterTableType::FOREIGN_KEY_CONSTRAINT: {
-		auto foreign_key_constraint_info = (AlterForeignKeyInfo *)table_info;
-		if (foreign_key_constraint_info->type == AlterForeignKeyType::AFT_ADD) {
-			return AddForeignKeyConstraint(context, *foreign_key_constraint_info);
+		auto &foreign_key_constraint_info = table_info.Cast<AlterForeignKeyInfo>();
+		if (foreign_key_constraint_info.type == AlterForeignKeyType::AFT_ADD) {
+			return AddForeignKeyConstraint(context, foreign_key_constraint_info);
 		} else {
-			return DropForeignKeyConstraint(context, *foreign_key_constraint_info);
+			return DropForeignKeyConstraint(context, foreign_key_constraint_info);
 		}
 	}
 	case AlterTableType::SET_NOT_NULL: {
-		auto set_not_null_info = (SetNotNullInfo *)table_info;
-		return SetNotNull(context, *set_not_null_info);
+		auto &set_not_null_info = table_info.Cast<SetNotNullInfo>();
+		return SetNotNull(context, set_not_null_info);
 	}
 	case AlterTableType::DROP_NOT_NULL: {
-		auto drop_not_null_info = (DropNotNullInfo *)table_info;
-		return DropNotNull(context, *drop_not_null_info);
+		auto &drop_not_null_info = table_info.Cast<DropNotNullInfo>();
+		return DropNotNull(context, drop_not_null_info);
 	}
 	default:
 		throw InternalException("Unrecognized alter table type!");
 	}
 }
 
-void DuckTableEntry::UndoAlter(ClientContext &context, AlterInfo *info) {
+void DuckTableEntry::UndoAlter(ClientContext &context, AlterInfo &info) {
 	D_ASSERT(!internal);
-	D_ASSERT(info->type == AlterType::ALTER_TABLE);
-	auto table_info = (AlterTableInfo *)info;
-	switch (table_info->alter_table_type) {
+	D_ASSERT(info.type == AlterType::ALTER_TABLE);
+	auto &table_info = info.Cast<AlterTableInfo>();
+	switch (table_info.alter_table_type) {
 	case AlterTableType::RENAME_TABLE: {
 		storage->info->table = this->name;
 		break;
@@ -266,7 +265,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::RenameColumn(ClientContext &context, Re
 	}
 	auto binder = Binder::CreateBinder(context);
 	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
-	return make_uniq<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
+	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::AddColumn(ClientContext &context, AddColumnInfo &info) {
@@ -286,7 +285,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::AddColumn(ClientContext &context, AddCo
 	for (auto &constraint : constraints) {
 		create_info->constraints.push_back(constraint->Copy());
 	}
-	Binder::BindLogicalType(context, info.new_column.TypeMutable(), catalog, schema->name);
+	Binder::BindLogicalType(context, info.new_column.TypeMutable(), &catalog, schema.name);
 	info.new_column.SetOid(columns.LogicalColumnCount());
 	info.new_column.SetStorageOid(columns.PhysicalColumnCount());
 	auto col = info.new_column.Copy();
@@ -297,7 +296,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::AddColumn(ClientContext &context, AddCo
 	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
 	auto new_storage =
 	    make_shared<DataTable>(context, *storage, info.new_column, bound_create_info->bound_defaults.back().get());
-	return make_uniq<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), new_storage);
+	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
 }
 
 void DuckTableEntry::UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_index,
@@ -428,11 +427,11 @@ unique_ptr<CatalogEntry> DuckTableEntry::RemoveColumn(ClientContext &context, Re
 	auto binder = Binder::CreateBinder(context);
 	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
 	if (columns.GetColumn(LogicalIndex(removed_index)).Generated()) {
-		return make_uniq<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
+		return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 	}
 	auto new_storage =
 	    make_shared<DataTable>(context, *storage, columns.LogicalToPhysical(LogicalIndex(removed_index)).index);
-	return make_uniq<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), new_storage);
+	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::SetDefault(ClientContext &context, SetDefaultInfo &info) {
@@ -462,7 +461,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::SetDefault(ClientContext &context, SetD
 
 	auto binder = Binder::CreateBinder(context);
 	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
-	return make_uniq<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
+	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::SetNotNull(ClientContext &context, SetNotNullInfo &info) {
@@ -493,13 +492,13 @@ unique_ptr<CatalogEntry> DuckTableEntry::SetNotNull(ClientContext &context, SetN
 
 	// Early return
 	if (has_not_null) {
-		return make_uniq<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
+		return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 	}
 
 	// Return with new storage info. Note that we need the bound column index here.
 	auto new_storage = make_shared<DataTable>(
 	    context, *storage, make_uniq<BoundNotNullConstraint>(columns.LogicalToPhysical(LogicalIndex(not_null_idx))));
-	return make_uniq<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), new_storage);
+	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::DropNotNull(ClientContext &context, DropNotNullInfo &info) {
@@ -521,13 +520,13 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropNotNull(ClientContext &context, Dro
 
 	auto binder = Binder::CreateBinder(context);
 	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
-	return make_uniq<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
+	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info) {
 	if (info.target_type.id() == LogicalTypeId::USER) {
 		info.target_type =
-		    Catalog::GetType(context, catalog->GetName(), schema->name, UserType::GetTypeName(info.target_type));
+		    Catalog::GetType(context, catalog.GetName(), schema.name, UserType::GetTypeName(info.target_type));
 	}
 	auto change_idx = GetColumnIndex(info.column_name);
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
@@ -611,8 +610,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context
 	auto new_storage =
 	    make_shared<DataTable>(context, *storage, columns.LogicalToPhysical(LogicalIndex(change_idx)).index,
 	                           info.target_type, std::move(storage_oids), *bound_expression);
-	auto result =
-	    make_uniq<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), new_storage);
+	auto result = make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
 	return std::move(result);
 }
 
@@ -637,7 +635,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::AddForeignKeyConstraint(ClientContext &
 	auto binder = Binder::CreateBinder(context);
 	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
 
-	return make_uniq<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
+	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::DropForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info) {
@@ -660,7 +658,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropForeignKeyConstraint(ClientContext
 	auto binder = Binder::CreateBinder(context);
 	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
 
-	return make_uniq<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
+	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::Copy(ClientContext &context) const {
@@ -674,7 +672,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::Copy(ClientContext &context) const {
 
 	auto binder = Binder::CreateBinder(context);
 	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
-	return make_uniq<DuckTableEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
+	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 
 void DuckTableEntry::SetAsRoot() {
@@ -712,7 +710,7 @@ const vector<unique_ptr<BoundConstraint>> &DuckTableEntry::GetBoundConstraints()
 }
 
 TableFunction DuckTableEntry::GetScanFunction(ClientContext &context, unique_ptr<FunctionData> &bind_data) {
-	bind_data = make_uniq<TableScanBindData>(this);
+	bind_data = make_uniq<TableScanBindData>(*this);
 	return TableScanFunction::GetFunction();
 }
 

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

@@ -4,9 +4,9 @@
 
 namespace duckdb {
 
-IndexCatalogEntry::IndexCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateIndexInfo *info)
-    : StandardEntry(CatalogType::INDEX_ENTRY, schema, catalog, info->index_name), index(nullptr), sql(info->sql) {
-	this->temporary = info->temporary;
+IndexCatalogEntry::IndexCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &info)
+    : StandardEntry(CatalogType::INDEX_ENTRY, schema, catalog, info.index_name), index(nullptr), sql(info.sql) {
+	this->temporary = info.temporary;
 }
 
 string IndexCatalogEntry::ToSQL() const {