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

package/src/duckdb/src/common/types.cpp

@@ -773,7 +773,7 @@ struct ExtraTypeInfo {
 
 	ExtraTypeInfoType type;
 	string alias;
-	TypeCatalogEntry *catalog_entry = nullptr;
+	optional_ptr<TypeCatalogEntry> catalog_entry;
 
 public:
 	bool Equals(ExtraTypeInfo *other_p) const {
@@ -845,21 +845,6 @@ bool LogicalType::HasAlias() const {
 	return false;
 }
 
-void LogicalType::SetCatalog(LogicalType &type, TypeCatalogEntry *catalog_entry) {
-	auto info = type.AuxInfo();
-	if (!info) {
-		return;
-	}
-	((ExtraTypeInfo &)*info).catalog_entry = catalog_entry;
-}
-TypeCatalogEntry *LogicalType::GetCatalog(const LogicalType &type) {
-	auto info = type.AuxInfo();
-	if (!info) {
-		return nullptr;
-	}
-	return ((ExtraTypeInfo &)*info).catalog_entry;
-}
-
 ExtraTypeInfoType LogicalType::GetExtraTypeInfoType(const ExtraTypeInfo &type) {
 	return type.type;
 }
@@ -1327,7 +1312,7 @@ struct EnumTypeInfo : public ExtraTypeInfo {
 		return enum_name;
 	};
 	const string GetSchemaName() const {
-		return catalog_entry ? catalog_entry->schema->name : "";
+		return catalog_entry ? catalog_entry->schema.name : "";
 	};
 	const Vector &GetValuesInsertOrder() {
 		return values_insert_order;
@@ -1536,22 +1521,25 @@ idx_t EnumType::GetSize(const LogicalType &type) {
 	return ((EnumTypeInfo &)*info).GetDictSize();
 }
 
-void EnumType::SetCatalog(LogicalType &type, TypeCatalogEntry *catalog_entry) {
-	D_ASSERT(type.id() == LogicalTypeId::ENUM);
+void EnumType::SetCatalog(LogicalType &type, optional_ptr<TypeCatalogEntry> catalog_entry) {
 	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	((EnumTypeInfo &)*info).catalog_entry = catalog_entry;
+	if (!info) {
+		return;
+	}
+	((ExtraTypeInfo &)*info).catalog_entry = catalog_entry;
 }
-TypeCatalogEntry *EnumType::GetCatalog(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ENUM);
+
+optional_ptr<TypeCatalogEntry> EnumType::GetCatalog(const LogicalType &type) {
 	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return ((EnumTypeInfo &)*info).catalog_entry;
+	if (!info) {
+		return nullptr;
+	}
+	return ((ExtraTypeInfo &)*info).catalog_entry;
 }
 
 string EnumType::GetSchemaName(const LogicalType &type) {
 	auto catalog_entry = EnumType::GetCatalog(type);
-	return catalog_entry ? catalog_entry->schema->name : "";
+	return catalog_entry ? catalog_entry->schema.name : "";
 }
 
 PhysicalType EnumType::GetPhysicalType(const LogicalType &type) {
@@ -1679,7 +1667,7 @@ shared_ptr<ExtraTypeInfo> ExtraTypeInfo::Deserialize(FieldReader &reader) {
 			// See if the serializer has a catalog
 			auto catalog = reader.GetSource().GetCatalog();
 			if (catalog) {
-				auto enum_type = catalog->GetType(client_context, schema_name, enum_name, true);
+				auto enum_type = catalog->GetType(client_context, schema_name, enum_name, OnEntryNotFound::RETURN_NULL);
 				if (enum_type != LogicalType::INVALID) {
 					extra_info = enum_type.GetAuxInfoShrPtr();
 				}

package/src/duckdb/src/execution/operator/join/physical_index_join.cpp

@@ -110,10 +110,10 @@ void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, Data
                                OperatorState &state_p) const {
 	auto &phy_tbl_scan = (PhysicalTableScan &)*children[1];
 	auto &bind_tbl = phy_tbl_scan.bind_data->Cast<TableScanBindData>();
-	auto &transaction = DuckTransaction::Get(context.client, *bind_tbl.table->catalog);
+	auto &transaction = DuckTransaction::Get(context.client, bind_tbl.table.catalog);
 	auto &state = state_p.Cast<IndexJoinOperatorState>();
 
-	auto &tbl = bind_tbl.table->GetStorage();
+	auto &tbl = bind_tbl.table.GetStorage();
 	idx_t output_sel_idx = 0;
 	vector<row_t> fetch_rows;
 

package/src/duckdb/src/execution/operator/persistent/physical_batch_insert.cpp

@@ -269,9 +269,10 @@ unique_ptr<GlobalSinkState> PhysicalBatchInsert::GetGlobalSinkState(ClientContex
 	if (info) {
 		// CREATE TABLE AS
 		D_ASSERT(!insert_table);
-		auto &catalog = *schema->catalog;
-		table = (TableCatalogEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(),
-		                                                 info.get());
+		auto &catalog = schema->catalog;
+		table = (TableCatalogEntry *)catalog
+		            .CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(), *info)
+		            .get();
 	} else {
 		D_ASSERT(insert_table);
 		D_ASSERT(insert_table->IsDuckTable());

package/src/duckdb/src/execution/operator/persistent/physical_export.cpp

@@ -117,31 +117,32 @@ void PhysicalExport::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	vector<reference<CatalogEntry>> macros;
 
 	auto schema_list = Catalog::GetSchemas(ccontext, info->catalog);
-	for (auto &schema : schema_list) {
-		if (!schema->internal) {
-			schemas.push_back(*schema);
+	for (auto &schema_p : schema_list) {
+		auto &schema = schema_p.get();
+		if (!schema.internal) {
+			schemas.push_back(schema);
 		}
-		schema->Scan(context.client, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
-			if (entry->internal) {
+		schema.Scan(context.client, CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
+			if (entry.internal) {
 				return;
 			}
-			if (entry->type != CatalogType::TABLE_ENTRY) {
-				views.push_back(*entry);
+			if (entry.type != CatalogType::TABLE_ENTRY) {
+				views.push_back(entry);
 			}
 		});
-		schema->Scan(context.client, CatalogType::SEQUENCE_ENTRY,
-		             [&](CatalogEntry *entry) { sequences.push_back(*entry); });
-		schema->Scan(context.client, CatalogType::TYPE_ENTRY,
-		             [&](CatalogEntry *entry) { custom_types.push_back(*entry); });
-		schema->Scan(context.client, CatalogType::INDEX_ENTRY, [&](CatalogEntry *entry) { indexes.push_back(*entry); });
-		schema->Scan(context.client, CatalogType::MACRO_ENTRY, [&](CatalogEntry *entry) {
-			if (!entry->internal && entry->type == CatalogType::MACRO_ENTRY) {
-				macros.push_back(*entry);
+		schema.Scan(context.client, CatalogType::SEQUENCE_ENTRY,
+		            [&](CatalogEntry &entry) { sequences.push_back(entry); });
+		schema.Scan(context.client, CatalogType::TYPE_ENTRY,
+		            [&](CatalogEntry &entry) { custom_types.push_back(entry); });
+		schema.Scan(context.client, CatalogType::INDEX_ENTRY, [&](CatalogEntry &entry) { indexes.push_back(entry); });
+		schema.Scan(context.client, CatalogType::MACRO_ENTRY, [&](CatalogEntry &entry) {
+			if (!entry.internal && entry.type == CatalogType::MACRO_ENTRY) {
+				macros.push_back(entry);
 			}
 		});
-		schema->Scan(context.client, CatalogType::TABLE_MACRO_ENTRY, [&](CatalogEntry *entry) {
-			if (!entry->internal && entry->type == CatalogType::TABLE_MACRO_ENTRY) {
-				macros.push_back(*entry);
+		schema.Scan(context.client, CatalogType::TABLE_MACRO_ENTRY, [&](CatalogEntry &entry) {
+			if (!entry.internal && entry.type == CatalogType::TABLE_MACRO_ENTRY) {
+				macros.push_back(entry);
 			}
 		});
 	}

package/src/duckdb/src/execution/operator/persistent/physical_insert.cpp

@@ -109,9 +109,9 @@ unique_ptr<GlobalSinkState> PhysicalInsert::GetGlobalSinkState(ClientContext &co
 	if (info) {
 		// CREATE TABLE AS
 		D_ASSERT(!insert_table);
-		auto &catalog = *schema->catalog;
-		table = (TableCatalogEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(),
-		                                                 info.get());
+		auto &catalog = schema->catalog;
+		table = &catalog.CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(), *info)
+		             ->Cast<TableCatalogEntry>();
 	} else {
 		D_ASSERT(insert_table);
 		D_ASSERT(insert_table->IsDuckTable());
@@ -313,7 +313,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionConte
 		// then we scan the existing table for the conflicting tuples, using the rowids
 		scan_chunk.Initialize(context.client, types_to_fetch);
 		auto fetch_state = make_uniq<ColumnFetchState>();
-		auto &transaction = DuckTransaction::Get(context.client, *table.catalog);
+		auto &transaction = DuckTransaction::Get(context.client, table.catalog);
 		data_table.Fetch(transaction, scan_chunk, columns_to_fetch, row_ids, conflicts.Count(), *fetch_state);
 	}
 
@@ -424,7 +424,7 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 		auto &table = gstate.table;
 		auto &storage = table.GetStorage();
 		storage.InitializeLocalAppend(gstate.append_state, context.client);
-		auto &transaction = DuckTransaction::Get(context.client, *table.catalog);
+		auto &transaction = DuckTransaction::Get(context.client, table.catalog);
 		lstate.local_collection->Scan(transaction, [&](DataChunk &insert_chunk) {
 			storage.LocalAppend(gstate.append_state, table, context.client, insert_chunk);
 			return true;

package/src/duckdb/src/execution/operator/schema/physical_alter.cpp

@@ -26,7 +26,7 @@ void PhysicalAlter::GetData(ExecutionContext &context, DataChunk &chunk, GlobalS
 		return;
 	}
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.Alter(context.client, info.get());
+	catalog.Alter(context.client, *info);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_function.cpp

@@ -27,7 +27,7 @@ void PhysicalCreateFunction::GetData(ExecutionContext &context, DataChunk &chunk
 		return;
 	}
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.CreateFunction(context.client, info.get());
+	catalog.CreateFunction(context.client, *info);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp

@@ -139,17 +139,18 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 		state.global_index->buffer_manager.IncreaseUsedMemory(state.global_index->memory_size);
 	}
 
-	auto &schema = *table.schema;
-	auto index_entry = (DuckIndexEntry *)schema.CreateIndex(context, info.get(), &table);
+	auto &schema = table.schema;
+	auto index_entry = schema.CreateIndex(context, *info, table).get();
 	if (!index_entry) {
 		// index already exists, but error ignored because of IF NOT EXISTS
 		return SinkFinalizeType::READY;
 	}
+	auto &index = index_entry->Cast<DuckIndexEntry>();
 
-	index_entry->index = state.global_index.get();
-	index_entry->info = storage.info;
+	index.index = state.global_index.get();
+	index.info = storage.info;
 	for (auto &parsed_expr : info->parsed_expressions) {
-		index_entry->parsed_expressions.push_back(parsed_expr->Copy());
+		index.parsed_expressions.push_back(parsed_expr->Copy());
 	}
 
 	storage.info->indexes.AddIndex(std::move(state.global_index));

package/src/duckdb/src/execution/operator/schema/physical_create_schema.cpp

@@ -28,7 +28,7 @@ void PhysicalCreateSchema::GetData(ExecutionContext &context, DataChunk &chunk,
 	if (catalog.IsSystemCatalog()) {
 		throw BinderException("Cannot create schema in system catalog");
 	}
-	catalog.CreateSchema(context.client, info.get());
+	catalog.CreateSchema(context.client, *info);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_sequence.cpp

@@ -25,7 +25,7 @@ void PhysicalCreateSequence::GetData(ExecutionContext &context, DataChunk &chunk
 		return;
 	}
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.CreateSequence(context.client, info.get());
+	catalog.CreateSequence(context.client, *info);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_table.cpp

@@ -34,8 +34,8 @@ void PhysicalCreateTable::GetData(ExecutionContext &context, DataChunk &chunk, G
 	if (state.finished) {
 		return;
 	}
-	auto &catalog = *schema.catalog;
-	catalog.CreateTable(catalog.GetCatalogTransaction(context.client), schema, info.get());
+	auto &catalog = schema.catalog;
+	catalog.CreateTable(catalog.GetCatalogTransaction(context.client), schema, *info);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_type.cpp

@@ -2,6 +2,7 @@
 
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/types/column/column_data_collection.hpp"
+#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 
 namespace duckdb {
 
@@ -86,10 +87,10 @@ void PhysicalCreateType::GetData(ExecutionContext &context, DataChunk &chunk, Gl
 	}
 
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	auto catalog_entry = catalog.CreateType(context.client, info.get());
+	auto catalog_entry = catalog.CreateType(context.client, *info);
 	D_ASSERT(catalog_entry->type == CatalogType::TYPE_ENTRY);
-	auto catalog_type = (TypeCatalogEntry *)catalog_entry;
-	LogicalType::SetCatalog(info->type, catalog_type);
+	auto &catalog_type = catalog_entry->Cast<TypeCatalogEntry>();
+	EnumType::SetCatalog(info->type, &catalog_type);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_view.cpp

@@ -25,7 +25,7 @@ void PhysicalCreateView::GetData(ExecutionContext &context, DataChunk &chunk, Gl
 		return;
 	}
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.CreateView(context.client, info.get());
+	catalog.CreateView(context.client, *info);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_detach.cpp

@@ -30,7 +30,7 @@ void PhysicalDetach::GetData(ExecutionContext &context, DataChunk &chunk, Global
 		return;
 	}
 	auto &db_manager = DatabaseManager::Get(context.client);
-	db_manager.DetachDatabase(context.client, info->name, info->if_exists);
+	db_manager.DetachDatabase(context.client, info->name, info->if_not_found);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_drop.cpp

@@ -40,7 +40,7 @@ void PhysicalDrop::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSo
 	}
 	case CatalogType::SCHEMA_ENTRY: {
 		auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-		catalog.DropEntry(context.client, info.get());
+		catalog.DropEntry(context.client, *info);
 		auto qualified_name = QualifiedName::Parse(info->name);
 
 		// Check if the dropped schema was set as the current schema
@@ -58,7 +58,7 @@ void PhysicalDrop::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSo
 	}
 	default: {
 		auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-		catalog.DropEntry(context.client, info.get());
+		catalog.DropEntry(context.client, *info);
 		break;
 	}
 	}

package/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp

@@ -124,7 +124,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAggregate
 
 	plan = ExtractAggregateExpressions(std::move(plan), op.expressions, op.groups);
 
-	if (op.groups.empty()) {
+	if (op.groups.empty() && op.grouping_sets.size() <= 1) {
 		// no groups, check if we can use a simple aggregation
 		// special case: aggregate entire columns together
 		bool use_simple_aggregation = true;

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -20,10 +20,10 @@
 namespace duckdb {
 
 static bool CanPlanIndexJoin(ClientContext &context, TableScanBindData &bind_data, PhysicalTableScan &scan) {
-	auto table = bind_data.table;
-	auto &transaction = DuckTransaction::Get(context, *table->catalog);
+	auto &table = bind_data.table;
+	auto &transaction = DuckTransaction::Get(context, table.catalog);
 	auto &local_storage = LocalStorage::Get(transaction);
-	if (local_storage.Find(table->GetStorage())) {
+	if (local_storage.Find(table.GetStorage())) {
 		// transaction local appends: skip index join
 		return false;
 	}
@@ -137,7 +137,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 
 static optional_ptr<Index> CanUseIndexJoin(TableScanBindData &tbl, Expression &expr) {
 	optional_ptr<Index> result;
-	tbl.table->GetStorage().info->indexes.Scan([&](Index &index) {
+	tbl.table.GetStorage().info->indexes.Scan([&](Index &index) {
 		if (index.unbound_expressions.size() != 1) {
 			return false;
 		}

package/src/duckdb/src/execution/physical_plan/plan_create_table.cpp

@@ -35,12 +35,13 @@ unique_ptr<PhysicalOperator> DuckCatalog::PlanCreateTableAs(ClientContext &conte
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateTable &op) {
 	const auto &create_info = (CreateTableInfo &)*op.info->base;
-	auto &catalog = *op.info->schema.catalog;
-	auto existing_entry = catalog.GetEntry<TableCatalogEntry>(context, create_info.schema, create_info.table, true);
+	auto &catalog = op.info->schema.catalog;
+	auto existing_entry = catalog.GetEntry<TableCatalogEntry>(context, create_info.schema, create_info.table,
+	                                                          OnEntryNotFound::RETURN_NULL);
 	bool replace = op.info->Base().on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT;
 	if ((!existing_entry || replace) && !op.children.empty()) {
 		auto plan = CreatePlan(*op.children[0]);
-		return op.schema.catalog->PlanCreateTableAs(context, op, std::move(plan));
+		return op.schema.catalog.PlanCreateTableAs(context, op, std::move(plan));
 	} else {
 		return make_uniq<PhysicalCreateTable>(op, op.schema, std::move(op.info), op.estimated_cardinality);
 	}

package/src/duckdb/src/execution/physical_plan/plan_delete.cpp

@@ -26,7 +26,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op
 	auto plan = CreatePlan(*op.children[0]);
 
 	dependencies.AddDependency(op.table);
-	return op.table.catalog->PlanDelete(context, op, std::move(plan));
+	return op.table.catalog.PlanDelete(context, op, std::move(plan));
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_insert.cpp

@@ -107,7 +107,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalInsert &op
 		plan = CreatePlan(*op.children[0]);
 	}
 	dependencies.AddDependency(op.table);
-	return op.table.catalog->PlanInsert(context, op, std::move(plan));
+	return op.table.catalog.PlanInsert(context, op, std::move(plan));
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_update.cpp

@@ -23,7 +23,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUpdate &op
 	auto plan = CreatePlan(*op.children[0]);
 
 	dependencies.AddDependency(op.table);
-	return op.table.catalog->PlanUpdate(context, op, std::move(plan));
+	return op.table.catalog.PlanUpdate(context, op, std::move(plan));
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/built_in_functions.cpp

@@ -21,37 +21,37 @@ void BuiltinFunctions::AddCollation(string name, ScalarFunction function, bool c
                                     bool not_required_for_equality) {
 	CreateCollationInfo info(std::move(name), std::move(function), combinable, not_required_for_equality);
 	info.internal = true;
-	catalog.CreateCollation(transaction, &info);
+	catalog.CreateCollation(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(AggregateFunctionSet set) {
 	CreateAggregateFunctionInfo info(std::move(set));
 	info.internal = true;
-	catalog.CreateFunction(transaction, &info);
+	catalog.CreateFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(AggregateFunction function) {
 	CreateAggregateFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreateFunction(transaction, &info);
+	catalog.CreateFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(PragmaFunction function) {
 	CreatePragmaFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreatePragmaFunction(transaction, &info);
+	catalog.CreatePragmaFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(const string &name, PragmaFunctionSet functions) {
 	CreatePragmaFunctionInfo info(name, std::move(functions));
 	info.internal = true;
-	catalog.CreatePragmaFunction(transaction, &info);
+	catalog.CreatePragmaFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(ScalarFunction function) {
 	CreateScalarFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreateFunction(transaction, &info);
+	catalog.CreateFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(const vector<string> &names, ScalarFunction function) { // NOLINT: false positive
@@ -64,25 +64,25 @@ void BuiltinFunctions::AddFunction(const vector<string> &names, ScalarFunction f
 void BuiltinFunctions::AddFunction(ScalarFunctionSet set) {
 	CreateScalarFunctionInfo info(std::move(set));
 	info.internal = true;
-	catalog.CreateFunction(transaction, &info);
+	catalog.CreateFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(TableFunction function) {
 	CreateTableFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreateTableFunction(transaction, &info);
+	catalog.CreateTableFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(TableFunctionSet set) {
 	CreateTableFunctionInfo info(std::move(set));
 	info.internal = true;
-	catalog.CreateTableFunction(transaction, &info);
+	catalog.CreateTableFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(CopyFunction function) {
 	CreateCopyFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreateCopyFunction(transaction, &info);
+	catalog.CreateCopyFunction(transaction, info);
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/function_binder.cpp

@@ -247,10 +247,10 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(const string &schema,
                                                           vector<unique_ptr<Expression>> children, string &error,
                                                           bool is_operator, Binder *binder) {
 	// bind the function
-	auto function =
+	auto &function =
 	    Catalog::GetSystemCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, schema, name);
-	D_ASSERT(function && function->type == CatalogType::SCALAR_FUNCTION_ENTRY);
-	return BindScalarFunction(function->Cast<ScalarFunctionCatalogEntry>(), std::move(children), error, is_operator,
+	D_ASSERT(function.type == CatalogType::SCALAR_FUNCTION_ENTRY);
+	return BindScalarFunction(function.Cast<ScalarFunctionCatalogEntry>(), std::move(children), error, is_operator,
 	                          binder);
 }
 

package/src/duckdb/src/function/scalar/list/list_aggregates.cpp

@@ -418,10 +418,9 @@ static unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, Scala
 
 	// look up the aggregate function in the catalog
 	QueryErrorContext error_context(nullptr, 0);
-	auto func =
-	    (AggregateFunctionCatalogEntry *)Catalog::GetSystemCatalog(context).GetEntry<AggregateFunctionCatalogEntry>(
-	        context, DEFAULT_SCHEMA, function_name, false, error_context);
-	D_ASSERT(func->type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
+	auto &func = Catalog::GetSystemCatalog(context).GetEntry<AggregateFunctionCatalogEntry>(
+	    context, DEFAULT_SCHEMA, function_name, error_context);
+	D_ASSERT(func.type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
 
 	if (is_parameter) {
 		bound_function.arguments[0] = LogicalTypeId::UNKNOWN;
@@ -439,13 +438,13 @@ static unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, Scala
 	}
 
 	FunctionBinder function_binder(context);
-	auto best_function_idx = function_binder.BindFunction(func->name, func->functions, types, error);
+	auto best_function_idx = function_binder.BindFunction(func.name, func.functions, types, error);
 	if (best_function_idx == DConstants::INVALID_INDEX) {
 		throw BinderException("No matching aggregate function\n%s", error);
 	}
 
 	// found a matching function, bind it as an aggregate
-	auto best_function = func->functions.GetFunctionByOffset(best_function_idx);
+	auto best_function = func.functions.GetFunctionByOffset(best_function_idx);
 	if (IS_AGGR) {
 		return ListAggregatesBindFunction<IS_AGGR>(context, bound_function, list_child_type, best_function, arguments);
 	}

package/src/duckdb/src/function/scalar/operators/arithmetic.cpp

@@ -167,8 +167,8 @@ static unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context,
 	} else {
 		// no potential overflow: replace with non-overflowing operator
 		if (input.bind_data) {
-			auto bind_data = (DecimalArithmeticBindData *)input.bind_data;
-			bind_data->check_overflow = false;
+			auto &bind_data = input.bind_data->Cast<DecimalArithmeticBindData>();
+			bind_data.check_overflow = false;
 		}
 		expr.function.function = GetScalarIntegerFunction<BASEOP>(expr.return_type.InternalType());
 	}

package/src/duckdb/src/function/scalar/sequence/nextval.cpp

@@ -76,7 +76,7 @@ struct NextSequenceValueOperator {
 	}
 };
 
-SequenceCatalogEntry *BindSequence(ClientContext &context, const string &name) {
+SequenceCatalogEntry &BindSequence(ClientContext &context, const string &name) {
 	auto qname = QualifiedName::Parse(name);
 	// fetch the sequence from the catalog
 	Binder::BindSchemaOrCatalog(context, qname.catalog, qname.schema);
@@ -91,36 +91,37 @@ static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &res
 
 	auto &context = state.GetContext();
 	if (info.sequence) {
-		auto &transaction = DuckTransaction::Get(context, *info.sequence->catalog);
+		auto &sequence = *info.sequence;
+		auto &transaction = DuckTransaction::Get(context, sequence.catalog);
 		// sequence to use is hard coded
 		// increment the sequence
 		result.SetVectorType(VectorType::FLAT_VECTOR);
 		auto result_data = FlatVector::GetData<int64_t>(result);
 		for (idx_t i = 0; i < args.size(); i++) {
 			// get the next value from the sequence
-			result_data[i] = OP::Operation(transaction, *info.sequence);
+			result_data[i] = OP::Operation(transaction, sequence);
 		}
 	} else {
 		// sequence to use comes from the input
 		UnaryExecutor::Execute<string_t, int64_t>(input, result, args.size(), [&](string_t value) {
 			// fetch the sequence from the catalog
-			auto sequence = BindSequence(context, value.GetString());
+			auto &sequence = BindSequence(context, value.GetString());
 			// finally get the next value from the sequence
-			auto &transaction = DuckTransaction::Get(context, *sequence->catalog);
-			return OP::Operation(transaction, *sequence);
+			auto &transaction = DuckTransaction::Get(context, sequence.catalog);
+			return OP::Operation(transaction, sequence);
 		});
 	}
 }
 
 static unique_ptr<FunctionData> NextValBind(ClientContext &context, ScalarFunction &bound_function,
                                             vector<unique_ptr<Expression>> &arguments) {
-	SequenceCatalogEntry *sequence = nullptr;
+	optional_ptr<SequenceCatalogEntry> sequence;
 	if (arguments[0]->IsFoldable()) {
 		// parameter to nextval function is a foldable constant
 		// evaluate the constant and perform the catalog lookup already
 		auto seqname = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
 		if (!seqname.IsNull()) {
-			sequence = BindSequence(context, seqname.ToString());
+			sequence = &BindSequence(context, seqname.ToString());
 		}
 	}
 	return make_uniq<NextvalBindData>(sequence);

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -197,22 +197,22 @@ static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, Scala
 	auto state_type = AggregateStateType::GetStateType(arg_return_type);
 
 	// now we can look up the function in the catalog again and bind it
-	auto func = Catalog::GetSystemCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, DEFAULT_SCHEMA,
-	                                                        state_type.function_name);
-	if (func->type != CatalogType::AGGREGATE_FUNCTION_ENTRY) {
+	auto &func = Catalog::GetSystemCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY,
+	                                                         DEFAULT_SCHEMA, state_type.function_name);
+	if (func.type != CatalogType::AGGREGATE_FUNCTION_ENTRY) {
 		throw InternalException("Could not find aggregate %s", state_type.function_name);
 	}
-	auto aggr = (AggregateFunctionCatalogEntry *)func;
+	auto &aggr = func.Cast<AggregateFunctionCatalogEntry>();
 
 	string error;
 
 	FunctionBinder function_binder(context);
 	idx_t best_function =
-	    function_binder.BindFunction(aggr->name, aggr->functions, state_type.bound_argument_types, error);
+	    function_binder.BindFunction(aggr.name, aggr.functions, state_type.bound_argument_types, error);
 	if (best_function == DConstants::INVALID_INDEX) {
 		throw InternalException("Could not re-bind exported aggregate %s: %s", state_type.function_name, error);
 	}
-	auto bound_aggr = aggr->functions.GetFunctionByOffset(best_function);
+	auto bound_aggr = aggr.functions.GetFunctionByOffset(best_function);
 	if (bound_aggr.bind) {
 		// FIXME: this is really hacky
 		// but the aggregate state export needs a rework around how it handles more complex aggregates anyway