duckdb 0.7.2-dev2507.0 → 0.7.2-dev2675.0

package/src/duckdb/src/function/table/system/duckdb_tables.cpp

@@ -17,7 +17,7 @@ struct DuckDBTablesData : public GlobalTableFunctionState {
 	DuckDBTablesData() : offset(0) {
 	}
 
-	vector<CatalogEntry *> entries;
+	vector<reference<CatalogEntry>> entries;
 	idx_t offset;
 };
 
@@ -74,7 +74,8 @@ unique_ptr<GlobalTableFunctionState> DuckDBTablesInit(ClientContext &context, Ta
 	// scan all the schemas for tables and collect themand collect them
 	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
+		schema.get().Scan(context, CatalogType::TABLE_ENTRY,
+		                  [&](CatalogEntry &entry) { result->entries.push_back(entry); });
 	};
 	return std::move(result);
 }
@@ -111,23 +112,23 @@ void DuckDBTablesFunction(ClientContext &context, TableFunctionInput &data_p, Da
 	// either fill up the chunk or return all the remaining columns
 	idx_t count = 0;
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++];
+		auto &entry = data.entries[data.offset++].get();
 
-		if (entry->type != CatalogType::TABLE_ENTRY) {
+		if (entry.type != CatalogType::TABLE_ENTRY) {
 			continue;
 		}
-		auto &table = entry->Cast<TableCatalogEntry>();
+		auto &table = entry.Cast<TableCatalogEntry>();
 		auto storage_info = table.GetStorageInfo(context);
 		// return values:
 		idx_t col = 0;
 		// database_name, VARCHAR
-		output.SetValue(col++, count, entry->catalog->GetName());
+		output.SetValue(col++, count, table.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(entry->catalog->GetOid()));
+		output.SetValue(col++, count, Value::BIGINT(table.catalog.GetOid()));
 		// schema_name, LogicalType::VARCHAR
-		output.SetValue(col++, count, Value(table.schema->name));
+		output.SetValue(col++, count, Value(table.schema.name));
 		// schema_oid, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(table.schema->oid));
+		output.SetValue(col++, count, Value::BIGINT(table.schema.oid));
 		// table_name, LogicalType::VARCHAR
 		output.SetValue(col++, count, Value(table.name));
 		// table_oid, LogicalType::BIGINT

package/src/duckdb/src/function/table/system/duckdb_types.cpp

@@ -13,7 +13,7 @@ struct DuckDBTypesData : public GlobalTableFunctionState {
 	DuckDBTypesData() : offset(0) {
 	}
 
-	vector<TypeCatalogEntry *> entries;
+	vector<reference<TypeCatalogEntry>> entries;
 	idx_t offset;
 	unordered_set<int64_t> oids;
 };
@@ -61,8 +61,8 @@ unique_ptr<GlobalTableFunctionState> DuckDBTypesInit(ClientContext &context, Tab
 	auto result = make_uniq<DuckDBTypesData>();
 	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::TYPE_ENTRY,
-		             [&](CatalogEntry *entry) { result->entries.push_back((TypeCatalogEntry *)entry); });
+		schema.get().Scan(context, CatalogType::TYPE_ENTRY,
+		                  [&](CatalogEntry &entry) { result->entries.push_back(entry.Cast<TypeCatalogEntry>()); });
 	};
 	return std::move(result);
 }
@@ -77,25 +77,25 @@ void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 	// either fill up the chunk or return all the remaining columns
 	idx_t count = 0;
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &type_entry = data.entries[data.offset++];
-		auto &type = type_entry->user_type;
+		auto &type_entry = data.entries[data.offset++].get();
+		auto &type = type_entry.user_type;
 
 		// return values:
 		idx_t col = 0;
 		// database_name, VARCHAR
-		output.SetValue(col++, count, type_entry->catalog->GetName());
+		output.SetValue(col++, count, type_entry.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(type_entry->catalog->GetOid()));
+		output.SetValue(col++, count, Value::BIGINT(type_entry.catalog.GetOid()));
 		// schema_name, LogicalType::VARCHAR
-		output.SetValue(col++, count, Value(type_entry->schema->name));
+		output.SetValue(col++, count, Value(type_entry.schema.name));
 		// schema_oid, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(type_entry->schema->oid));
+		output.SetValue(col++, count, Value::BIGINT(type_entry.schema.oid));
 		// type_oid, BIGINT
 		int64_t oid;
-		if (type_entry->internal) {
+		if (type_entry.internal) {
 			oid = int64_t(type.id());
 		} else {
-			oid = type_entry->oid;
+			oid = type_entry.oid;
 		}
 		Value oid_val;
 		if (data.oids.find(oid) == data.oids.end()) {
@@ -106,7 +106,7 @@ void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 		}
 		output.SetValue(col++, count, oid_val);
 		// type_name, VARCHAR
-		output.SetValue(col++, count, Value(type_entry->name));
+		output.SetValue(col++, count, Value(type_entry.name));
 		// type_size, BIGINT
 		auto internal_type = type.InternalType();
 		output.SetValue(col++, count,
@@ -159,7 +159,7 @@ void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 		}
 		output.SetValue(col++, count, category.empty() ? Value() : Value(category));
 		// internal, BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(type_entry->internal));
+		output.SetValue(col++, count, Value::BOOLEAN(type_entry.internal));
 		// labels, VARCHAR[]
 		if (type.id() == LogicalTypeId::ENUM && type.AuxInfo()) {
 			auto data = FlatVector::GetData<string_t>(EnumType::GetValuesInsertOrder(type));

package/src/duckdb/src/function/table/system/duckdb_views.cpp

@@ -13,7 +13,7 @@ struct DuckDBViewsData : public GlobalTableFunctionState {
 	DuckDBViewsData() : offset(0) {
 	}
 
-	vector<CatalogEntry *> entries;
+	vector<reference<CatalogEntry>> entries;
 	idx_t offset;
 };
 
@@ -58,13 +58,14 @@ unique_ptr<GlobalTableFunctionState> DuckDBViewsInit(ClientContext &context, Tab
 	// scan all the schemas for tables and collect them and collect them
 	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::VIEW_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
+		schema.get().Scan(context, CatalogType::VIEW_ENTRY,
+		                  [&](CatalogEntry &entry) { result->entries.push_back(entry); });
 	};
 	return std::move(result);
 }
 
 void DuckDBViewsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBViewsData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<DuckDBViewsData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -73,23 +74,23 @@ void DuckDBViewsFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 	// either fill up the chunk or return all the remaining columns
 	idx_t count = 0;
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset++];
+		auto &entry = data.entries[data.offset++].get();
 
-		if (entry->type != CatalogType::VIEW_ENTRY) {
+		if (entry.type != CatalogType::VIEW_ENTRY) {
 			continue;
 		}
-		auto &view = entry->Cast<ViewCatalogEntry>();
+		auto &view = entry.Cast<ViewCatalogEntry>();
 
 		// return values:
 		idx_t col = 0;
 		// database_name, VARCHAR
-		output.SetValue(col++, count, entry->catalog->GetName());
+		output.SetValue(col++, count, view.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(entry->catalog->GetOid()));
+		output.SetValue(col++, count, Value::BIGINT(view.catalog.GetOid()));
 		// schema_name, LogicalType::VARCHAR
-		output.SetValue(col++, count, Value(view.schema->name));
+		output.SetValue(col++, count, Value(view.schema.name));
 		// schema_oid, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(view.schema->oid));
+		output.SetValue(col++, count, Value::BIGINT(view.schema.oid));
 		// view_name, LogicalType::VARCHAR
 		output.SetValue(col++, count, Value(view.name));
 		// view_oid, LogicalType::BIGINT

package/src/duckdb/src/function/table/system/pragma_collations.cpp

@@ -28,8 +28,8 @@ unique_ptr<GlobalTableFunctionState> PragmaCollateInit(ClientContext &context, T
 
 	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto schema : schemas) {
-		schema->Scan(context, CatalogType::COLLATION_ENTRY,
-		             [&](CatalogEntry *entry) { result->entries.push_back(entry->name); });
+		schema.get().Scan(context, CatalogType::COLLATION_ENTRY,
+		                  [&](CatalogEntry &entry) { result->entries.push_back(entry.name); });
 	}
 	return std::move(result);
 }

package/src/duckdb/src/function/table/system/pragma_database_size.cpp

@@ -15,7 +15,7 @@ struct PragmaDatabaseSizeData : public GlobalTableFunctionState {
 	}
 
 	idx_t index;
-	vector<optional_ptr<AttachedDatabase>> databases;
+	vector<reference<AttachedDatabase>> databases;
 	Value memory_usage;
 	Value memory_limit;
 };
@@ -68,13 +68,13 @@ void PragmaDatabaseSizeFunction(ClientContext &context, TableFunctionInput &data
 	auto &data = data_p.global_state->Cast<PragmaDatabaseSizeData>();
 	idx_t row = 0;
 	for (; data.index < data.databases.size() && row < STANDARD_VECTOR_SIZE; data.index++) {
-		auto db = data.databases[data.index];
-		if (db->IsSystem() || db->IsTemporary()) {
+		auto &db = data.databases[data.index].get();
+		if (db.IsSystem() || db.IsTemporary()) {
 			continue;
 		}
-		auto ds = db->GetCatalog().GetDatabaseSize(context);
+		auto ds = db.GetCatalog().GetDatabaseSize(context);
 		idx_t col = 0;
-		output.data[col++].SetValue(row, Value(db->GetName()));
+		output.data[col++].SetValue(row, Value(db.GetName()));
 		output.data[col++].SetValue(row, Value(StringUtil::BytesToHumanReadableString(ds.bytes)));
 		output.data[col++].SetValue(row, Value::BIGINT(ds.block_size));
 		output.data[col++].SetValue(row, Value::BIGINT(ds.total_blocks));

package/src/duckdb/src/function/table/system/pragma_storage_info.cpp

@@ -80,9 +80,9 @@ static unique_ptr<FunctionData> PragmaStorageInfoBind(ClientContext &context, Ta
 
 	// look up the table name in the catalog
 	Binder::BindSchemaOrCatalog(context, qname.catalog, qname.schema);
-	auto table_entry = Catalog::GetEntry<TableCatalogEntry>(context, qname.catalog, qname.schema, qname.name);
-	auto result = make_uniq<PragmaStorageFunctionData>(*table_entry);
-	result->storage_info = table_entry->GetStorageInfo(context);
+	auto &table_entry = Catalog::GetEntry<TableCatalogEntry>(context, qname.catalog, qname.schema, qname.name);
+	auto result = make_uniq<PragmaStorageFunctionData>(table_entry);
+	result->storage_info = table_entry.GetStorageInfo(context);
 	return std::move(result);
 }
 

package/src/duckdb/src/function/table/system/pragma_table_info.cpp

@@ -54,8 +54,8 @@ static unique_ptr<FunctionData> PragmaTableInfoBind(ClientContext &context, Tabl
 
 	// look up the table name in the catalog
 	Binder::BindSchemaOrCatalog(context, qname.catalog, qname.schema);
-	auto entry = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, qname.catalog, qname.schema, qname.name);
-	return make_uniq<PragmaTableFunctionData>(*entry);
+	auto &entry = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, qname.catalog, qname.schema, qname.name);
+	return make_uniq<PragmaTableFunctionData>(entry);
 }
 
 unique_ptr<GlobalTableFunctionState> PragmaTableInfoInit(ClientContext &context, TableFunctionInitInput &input) {

package/src/duckdb/src/function/table/table_scan.cpp

@@ -43,7 +43,7 @@ struct TableScanGlobalState : public GlobalTableFunctionState {
 	TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) {
 		D_ASSERT(bind_data_p);
 		auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-		max_threads = bind_data.table->GetStorage().MaxThreads(context);
+		max_threads = bind_data.table.GetStorage().MaxThreads(context);
 	}
 
 	ParallelTableScanState state;
@@ -67,11 +67,11 @@ static unique_ptr<LocalTableFunctionState> TableScanInitLocal(ExecutionContext &
 	auto &bind_data = input.bind_data->Cast<TableScanBindData>();
 	vector<column_t> column_ids = input.column_ids;
 	for (auto &col : column_ids) {
-		auto storage_idx = GetStorageIndex(*bind_data.table, col);
+		auto storage_idx = GetStorageIndex(bind_data.table, col);
 		col = storage_idx;
 	}
-	result->scan_state.Initialize(std::move(column_ids), input.filters);
-	TableScanParallelStateNext(context.client, input.bind_data, result.get(), gstate);
+	result->scan_state.Initialize(std::move(column_ids), input.filters.get());
+	TableScanParallelStateNext(context.client, input.bind_data.get(), result.get(), gstate);
 	if (input.CanRemoveFilterColumns()) {
 		auto &tsgs = gstate->Cast<TableScanGlobalState>();
 		result->all_columns.Initialize(context.client, tsgs.scanned_types);
@@ -83,11 +83,11 @@ unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context,
 
 	D_ASSERT(input.bind_data);
 	auto &bind_data = input.bind_data->Cast<TableScanBindData>();
-	auto result = make_uniq<TableScanGlobalState>(context, input.bind_data);
-	bind_data.table->GetStorage().InitializeParallelScan(context, result->state);
+	auto result = make_uniq<TableScanGlobalState>(context, input.bind_data.get());
+	bind_data.table.GetStorage().InitializeParallelScan(context, result->state);
 	if (input.CanRemoveFilterColumns()) {
 		result->projection_ids = input.projection_ids;
-		const auto &columns = bind_data.table->GetColumns();
+		const auto &columns = bind_data.table.GetColumns();
 		for (const auto &col_idx : input.column_ids) {
 			if (col_idx == COLUMN_IDENTIFIER_ROW_ID) {
 				result->scanned_types.emplace_back(LogicalType::ROW_TYPE);
@@ -102,20 +102,20 @@ unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context,
 static unique_ptr<BaseStatistics> TableScanStatistics(ClientContext &context, const FunctionData *bind_data_p,
                                                       column_t column_id) {
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	auto &local_storage = LocalStorage::Get(context, *bind_data.table->catalog);
-	if (local_storage.Find(bind_data.table->GetStorage())) {
+	auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog);
+	if (local_storage.Find(bind_data.table.GetStorage())) {
 		// we don't emit any statistics for tables that have outstanding transaction-local data
 		return nullptr;
 	}
-	return bind_data.table->GetStatistics(context, column_id);
+	return bind_data.table.GetStatistics(context, column_id);
 }
 
 static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = data_p.bind_data->Cast<TableScanBindData>();
 	auto &gstate = data_p.global_state->Cast<TableScanGlobalState>();
 	auto &state = data_p.local_state->Cast<TableScanLocalState>();
-	auto &transaction = DuckTransaction::Get(context, *bind_data.table->catalog);
-	auto &storage = bind_data.table->GetStorage();
+	auto &transaction = DuckTransaction::Get(context, bind_data.table.catalog);
+	auto &storage = bind_data.table.GetStorage();
 	do {
 		if (bind_data.is_create_index) {
 			storage.CreateIndexScan(state.scan_state, output,
@@ -130,7 +130,8 @@ static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, Da
 		if (output.size() > 0) {
 			return;
 		}
-		if (!TableScanParallelStateNext(context, data_p.bind_data, data_p.local_state, data_p.global_state)) {
+		if (!TableScanParallelStateNext(context, data_p.bind_data.get(), data_p.local_state.get(),
+		                                data_p.global_state.get())) {
 			return;
 		}
 	} while (true);
@@ -141,7 +142,7 @@ bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 	auto &parallel_state = global_state->Cast<TableScanGlobalState>();
 	auto &state = local_state->Cast<TableScanLocalState>();
-	auto &storage = bind_data.table->GetStorage();
+	auto &storage = bind_data.table.GetStorage();
 
 	return storage.NextParallelScan(context, parallel_state.state, state.scan_state);
 }
@@ -150,7 +151,7 @@ double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p
                          const GlobalTableFunctionState *gstate_p) {
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 	auto &gstate = gstate_p->Cast<TableScanGlobalState>();
-	auto &storage = bind_data.table->GetStorage();
+	auto &storage = bind_data.table.GetStorage();
 	idx_t total_rows = storage.GetTotalRows();
 	if (total_rows == 0) {
 		//! Table is either empty or smaller than a vector size, so it is finished
@@ -185,14 +186,14 @@ BindInfo TableScanGetBindInfo(const FunctionData *bind_data) {
 
 void TableScanDependency(DependencyList &entries, const FunctionData *bind_data_p) {
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	entries.AddDependency(*bind_data.table);
+	entries.AddDependency(bind_data.table);
 }
 
 unique_ptr<NodeStatistics> TableScanCardinality(ClientContext &context, const FunctionData *bind_data_p) {
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	auto &local_storage = LocalStorage::Get(context, *bind_data.table->catalog);
-	auto &storage = bind_data.table->GetStorage();
-	idx_t estimated_cardinality = storage.info->cardinality + local_storage.AddedRows(bind_data.table->GetStorage());
+	auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog);
+	auto &storage = bind_data.table.GetStorage();
+	idx_t estimated_cardinality = storage.info->cardinality + local_storage.AddedRows(bind_data.table.GetStorage());
 	return make_uniq<NodeStatistics>(storage.info->cardinality, estimated_cardinality);
 }
 
@@ -217,10 +218,10 @@ static unique_ptr<GlobalTableFunctionState> IndexScanInitGlobal(ClientContext &c
 		row_id_data = (data_ptr_t)&bind_data.result_ids[0];
 	}
 	auto result = make_uniq<IndexScanGlobalState>(row_id_data);
-	auto &local_storage = LocalStorage::Get(context, *bind_data.table->catalog);
+	auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog);
 	result->column_ids = input.column_ids;
-	result->local_storage_state.Initialize(input.column_ids, input.filters);
-	local_storage.InitializeScan(bind_data.table->GetStorage(), result->local_storage_state.local_state, input.filters);
+	result->local_storage_state.Initialize(input.column_ids, input.filters.get());
+	local_storage.InitializeScan(bind_data.table.GetStorage(), result->local_storage_state.local_state, input.filters);
 
 	result->finished = false;
 	return std::move(result);
@@ -229,12 +230,12 @@ static unique_ptr<GlobalTableFunctionState> IndexScanInitGlobal(ClientContext &c
 static void IndexScanFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = data_p.bind_data->Cast<TableScanBindData>();
 	auto &state = data_p.global_state->Cast<IndexScanGlobalState>();
-	auto &transaction = DuckTransaction::Get(context, *bind_data.table->catalog);
+	auto &transaction = DuckTransaction::Get(context, bind_data.table.catalog);
 	auto &local_storage = LocalStorage::Get(transaction);
 
 	if (!state.finished) {
-		bind_data.table->GetStorage().Fetch(transaction, output, state.column_ids, state.row_ids,
-		                                    bind_data.result_ids.size(), state.fetch_state);
+		bind_data.table.GetStorage().Fetch(transaction, output, state.column_ids, state.row_ids,
+		                                   bind_data.result_ids.size(), state.fetch_state);
 		state.finished = true;
 	}
 	if (output.size() == 0) {
@@ -265,8 +266,8 @@ static void RewriteIndexExpression(Index &index, LogicalGet &get, Expression &ex
 void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, FunctionData *bind_data_p,
                                     vector<unique_ptr<Expression>> &filters) {
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	auto table = bind_data.table;
-	auto &storage = table->GetStorage();
+	auto &table = bind_data.table;
+	auto &storage = table.GetStorage();
 
 	auto &config = ClientConfig::GetConfig(context);
 	if (!config.enable_optimizer) {
@@ -365,7 +366,7 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 		}
 		if (!equal_value.IsNull() || !low_value.IsNull() || !high_value.IsNull()) {
 			// we can scan this index using this predicate: try a scan
-			auto &transaction = Transaction::Get(context, *bind_data.table->catalog);
+			auto &transaction = Transaction::Get(context, bind_data.table.catalog);
 			unique_ptr<IndexScanState> index_state;
 			if (!equal_value.IsNull()) {
 				// equality predicate
@@ -397,19 +398,19 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 
 string TableScanToString(const FunctionData *bind_data_p) {
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	string result = bind_data.table->name;
+	string result = bind_data.table.name;
 	return result;
 }
 
 static void TableScanSerialize(FieldWriter &writer, const FunctionData *bind_data_p, const TableFunction &function) {
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 
-	writer.WriteString(bind_data.table->schema->name);
-	writer.WriteString(bind_data.table->name);
+	writer.WriteString(bind_data.table.schema.name);
+	writer.WriteString(bind_data.table.name);
 	writer.WriteField<bool>(bind_data.is_index_scan);
 	writer.WriteField<bool>(bind_data.is_create_index);
 	writer.WriteList<row_t>(bind_data.result_ids);
-	writer.WriteString(bind_data.table->schema->catalog->GetName());
+	writer.WriteString(bind_data.table.schema.catalog.GetName());
 }
 
 static unique_ptr<FunctionData> TableScanDeserialize(ClientContext &context, FieldReader &reader,
@@ -421,12 +422,12 @@ static unique_ptr<FunctionData> TableScanDeserialize(ClientContext &context, Fie
 	auto result_ids = reader.ReadRequiredList<row_t>();
 	auto catalog_name = reader.ReadField<string>(INVALID_CATALOG);
 
-	auto catalog_entry = Catalog::GetEntry<TableCatalogEntry>(context, catalog_name, schema_name, table_name);
-	if (!catalog_entry || catalog_entry->type != CatalogType::TABLE_ENTRY) {
+	auto &catalog_entry = Catalog::GetEntry<TableCatalogEntry>(context, catalog_name, schema_name, table_name);
+	if (catalog_entry.type != CatalogType::TABLE_ENTRY) {
 		throw SerializationException("Cant find table for %s.%s", schema_name, table_name);
 	}
 
-	auto result = make_uniq<TableScanBindData>((DuckTableEntry *)catalog_entry);
+	auto result = make_uniq<TableScanBindData>(catalog_entry.Cast<DuckTableEntry>());
 	result->is_index_scan = is_index_scan;
 	result->is_create_index = is_create_index;
 	result->result_ids = std::move(result_ids);
@@ -471,12 +472,13 @@ TableFunction TableScanFunction::GetFunction() {
 	return scan_function;
 }
 
-TableCatalogEntry *TableScanFunction::GetTableEntry(const TableFunction &function, const FunctionData *bind_data_p) {
+optional_ptr<TableCatalogEntry> TableScanFunction::GetTableEntry(const TableFunction &function,
+                                                                 const optional_ptr<FunctionData> bind_data_p) {
 	if (function.function != TableScanFunc || !bind_data_p) {
 		return nullptr;
 	}
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	return bind_data.table;
+	return &bind_data.table;
 }
 
 void TableScanFunction::RegisterFunction(BuiltinFunctions &set) {

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev2507"
+#define DUCKDB_VERSION "0.7.2-dev2675"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "c5737e4a94"
+#define DUCKDB_SOURCE_ID "688b2f1f8c"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/function/udf_function.cpp

@@ -15,13 +15,13 @@ void UDFWrapper::RegisterFunction(string name, vector<LogicalType> args, Logical
 	scalar_function.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	CreateScalarFunctionInfo info(scalar_function);
 	info.schema = DEFAULT_SCHEMA;
-	context.RegisterFunction(&info);
+	context.RegisterFunction(info);
 }
 
 void UDFWrapper::RegisterAggrFunction(AggregateFunction aggr_function, ClientContext &context, LogicalType varargs) {
 	aggr_function.varargs = std::move(varargs);
 	CreateAggregateFunctionInfo info(std::move(aggr_function));
-	context.RegisterFunction(&info);
+	context.RegisterFunction(info);
 }
 
 } // namespace duckdb