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

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

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

@@ -271,8 +271,8 @@ unique_ptr<GlobalTableFunctionState> ArrowTableFunction::ArrowScanInitGlobal(Cli
                                                                              TableFunctionInitInput &input) {
 	auto &bind_data = (const ArrowScanFunctionData &)*input.bind_data;
 	auto result = make_uniq<ArrowScanGlobalState>();
-	result->stream = ProduceArrowScan(bind_data, input.column_ids, input.filters);
-	result->max_threads = ArrowScanMaxThreads(context, input.bind_data);
+	result->stream = ProduceArrowScan(bind_data, input.column_ids, input.filters.get());
+	result->max_threads = ArrowScanMaxThreads(context, input.bind_data.get());
 	if (input.CanRemoveFilterColumns()) {
 		result->projection_ids = input.projection_ids;
 		for (const auto &col_idx : input.column_ids) {
@@ -293,12 +293,12 @@ unique_ptr<LocalTableFunctionState> ArrowTableFunction::ArrowScanInitLocal(Execu
 	auto current_chunk = make_uniq<ArrowArrayWrapper>();
 	auto result = make_uniq<ArrowScanLocalState>(std::move(current_chunk));
 	result->column_ids = input.column_ids;
-	result->filters = input.filters;
+	result->filters = input.filters.get();
 	if (input.CanRemoveFilterColumns()) {
 		auto &asgs = global_state_p->Cast<ArrowScanGlobalState>();
 		result->all_columns.Initialize(context.client, asgs.scanned_types);
 	}
-	if (!ArrowScanParallelStateNext(context.client, input.bind_data, *result, global_state)) {
+	if (!ArrowScanParallelStateNext(context.client, input.bind_data.get(), *result, global_state)) {
 		return nullptr;
 	}
 	return std::move(result);
@@ -314,7 +314,7 @@ void ArrowTableFunction::ArrowScanFunction(ClientContext &context, TableFunction
 
 	//! Out of tuples in this chunk
 	if (state.chunk_offset >= (idx_t)state.chunk->arrow_array.length) {
-		if (!ArrowScanParallelStateNext(context, data_p.bind_data, state, global_state)) {
+		if (!ArrowScanParallelStateNext(context, data_p.bind_data.get(), state, global_state)) {
 			return;
 		}
 	}

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

@@ -27,7 +27,7 @@ unique_ptr<CSVFileHandle> ReadCSV::OpenCSV(const string &file_path, FileCompress
 	if (file_handle->CanSeek()) {
 		file_handle->Reset();
 	}
-	return make_uniq<CSVFileHandle>(std::move(file_handle));
+	return make_uniq<CSVFileHandle>(std::move(file_handle), false);
 }
 
 void ReadCSVData::FinalizeRead(ClientContext &context) {
@@ -259,6 +259,7 @@ public:
 	                       idx_t rows_to_skip, bool force_parallelism_p, vector<column_t> column_ids_p)
 	    : file_handle(std::move(file_handle_p)), system_threads(system_threads_p), buffer_size(buffer_size_p),
 	      force_parallelism(force_parallelism_p), column_ids(std::move(column_ids_p)) {
+		file_handle->DisableReset();
 		current_file_path = files_path_p[0];
 		estimated_linenr = rows_to_skip;
 		file_size = file_handle->FileSize();
@@ -861,6 +862,7 @@ static void ReadCSVAddNamedParameters(TableFunction &table_function) {
 	table_function.named_parameters["decimal_separator"] = LogicalType::VARCHAR;
 	table_function.named_parameters["parallel"] = LogicalType::BOOLEAN;
 	table_function.named_parameters["null_padding"] = LogicalType::BOOLEAN;
+	table_function.named_parameters["allow_quoted_nulls"] = LogicalType::BOOLEAN;
 	table_function.named_parameters["column_types"] = LogicalType::ANY;
 	table_function.named_parameters["dtypes"] = LogicalType::ANY;
 	table_function.named_parameters["types"] = LogicalType::ANY;
@@ -920,6 +922,7 @@ void BufferedCSVReaderOptions::Serialize(FieldWriter &writer) const {
 	writer.WriteString(null_str);
 	writer.WriteField<FileCompressionType>(compression);
 	writer.WriteField<NewLineIdentifier>(new_line);
+	writer.WriteField<bool>(allow_quoted_nulls);
 	// read options
 	writer.WriteField<idx_t>(skip_rows);
 	writer.WriteField<bool>(skip_rows_set);
@@ -954,6 +957,7 @@ void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
 	null_str = reader.ReadRequired<string>();
 	compression = reader.ReadRequired<FileCompressionType>();
 	new_line = reader.ReadRequired<NewLineIdentifier>();
+	allow_quoted_nulls = reader.ReadRequired<bool>();
 	// read options
 	skip_rows = reader.ReadRequired<idx_t>();
 	skip_rows_set = reader.ReadRequired<bool>();

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

@@ -16,7 +16,7 @@ struct DuckDBColumnsData : public GlobalTableFunctionState {
 	DuckDBColumnsData() : offset(0), column_offset(0) {
 	}
 
-	vector<optional_ptr<CatalogEntry>> entries;
+	vector<reference<CatalogEntry>> entries;
 	idx_t offset;
 	idx_t column_offset;
 };
@@ -83,7 +83,8 @@ unique_ptr<GlobalTableFunctionState> DuckDBColumnsInit(ClientContext &context, T
 	// scan all the schemas for tables and views and 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);
 }
@@ -190,13 +191,13 @@ void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_co
 
 		idx_t col = 0;
 		// database_name, VARCHAR
-		output.SetValue(col++, index, entry.catalog->GetName());
+		output.SetValue(col++, index, entry.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, index, Value::BIGINT(entry.catalog->GetOid()));
+		output.SetValue(col++, index, Value::BIGINT(entry.catalog.GetOid()));
 		// schema_name, VARCHAR
-		output.SetValue(col++, index, entry.schema->name);
+		output.SetValue(col++, index, entry.schema.name);
 		// schema_oid, BIGINT
-		output.SetValue(col++, index, Value::BIGINT(entry.schema->oid));
+		output.SetValue(col++, index, Value::BIGINT(entry.schema.oid));
 		// table_name, VARCHAR
 		output.SetValue(col++, index, entry.name);
 		// table_oid, BIGINT
@@ -298,7 +299,7 @@ void DuckDBColumnsFunction(ClientContext &context, TableFunctionInput &data_p, D
 	idx_t column_offset = data.column_offset;
 	idx_t index = 0;
 	while (next < data.entries.size() && index < STANDARD_VECTOR_SIZE) {
-		auto column_helper = ColumnHelper::Create(*data.entries[next]);
+		auto column_helper = ColumnHelper::Create(data.entries[next].get());
 		idx_t columns = column_helper->NumColumns();
 
 		// Check to see if we are going to exceed the maximum index for a DataChunk

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

@@ -53,7 +53,7 @@ struct DuckDBConstraintsData : public GlobalTableFunctionState {
 	DuckDBConstraintsData() : offset(0), constraint_offset(0), unique_constraint_offset(0) {
 	}
 
-	vector<optional_ptr<CatalogEntry>> entries;
+	vector<reference<CatalogEntry>> entries;
 	idx_t offset;
 	idx_t constraint_offset;
 	idx_t unique_constraint_offset;
@@ -109,15 +109,15 @@ unique_ptr<GlobalTableFunctionState> DuckDBConstraintsInit(ClientContext &contex
 	auto schemas = Catalog::GetAllSchemas(context);
 
 	for (auto &schema : schemas) {
-		vector<CatalogEntry *> entries;
+		vector<reference<CatalogEntry>> entries;
 
-		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
-			if (entry->type == CatalogType::TABLE_ENTRY) {
+		schema.get().Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
+			if (entry.type == CatalogType::TABLE_ENTRY) {
 				entries.push_back(entry);
 			}
 		});
 
-		sort(entries.begin(), entries.end(), [&](CatalogEntry *x, CatalogEntry *y) { return (x->name < y->name); });
+		sort(entries.begin(), entries.end(), [&](CatalogEntry &x, CatalogEntry &y) { return (x.name < y.name); });
 
 		result->entries.insert(result->entries.end(), entries.begin(), entries.end());
 	};
@@ -135,7 +135,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 	// 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();
 		D_ASSERT(entry.type == CatalogType::TABLE_ENTRY);
 
 		auto &table = entry.Cast<TableCatalogEntry>();
@@ -178,13 +178,13 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 
 			idx_t col = 0;
 			// database_name, LogicalType::VARCHAR
-			output.SetValue(col++, count, Value(table.schema->catalog->GetName()));
+			output.SetValue(col++, count, Value(table.schema.catalog.GetName()));
 			// database_oid, LogicalType::BIGINT
-			output.SetValue(col++, count, Value::BIGINT(table.schema->catalog->GetOid()));
+			output.SetValue(col++, count, Value::BIGINT(table.schema.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
@@ -198,15 +198,15 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 				switch (bound_constraint.type) {
 				case ConstraintType::UNIQUE: {
 					auto &bound_unique = bound_constraint.Cast<BoundUniqueConstraint>();
-					uk_info = {table.schema->name, table.name, bound_unique.keys};
+					uk_info = {table.schema.name, table.name, bound_unique.keys};
 					break;
 				}
 				case ConstraintType::FOREIGN_KEY: {
 					const auto &bound_foreign_key = bound_constraint.Cast<BoundForeignKeyConstraint>();
 					const auto &info = bound_foreign_key.info;
 					// find the other table
-					auto table_entry = Catalog::GetEntry<TableCatalogEntry>(context, table.catalog->GetName(),
-					                                                        info.schema, info.table, true);
+					auto table_entry = Catalog::GetEntry<TableCatalogEntry>(
+					    context, table.catalog.GetName(), info.schema, info.table, OnEntryNotFound::RETURN_NULL);
 					if (!table_entry) {
 						throw InternalException("dukdb_constraints: entry %s.%s referenced in foreign key not found",
 						                        info.schema, info.table);
@@ -215,7 +215,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 					for (auto &key : info.pk_keys) {
 						index.push_back(table_entry->GetColumns().PhysicalToLogical(key));
 					}
-					uk_info = {table_entry->schema->name, table_entry->name, index};
+					uk_info = {table_entry->schema.name, table_entry->name, index};
 					break;
 				}
 				default:

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

@@ -8,7 +8,7 @@ struct DuckDBDatabasesData : public GlobalTableFunctionState {
 	DuckDBDatabasesData() : offset(0) {
 	}
 
-	vector<optional_ptr<AttachedDatabase>> entries;
+	vector<reference<AttachedDatabase>> entries;
 	idx_t offset;
 };
 
@@ -53,7 +53,7 @@ void DuckDBDatabasesFunction(ClientContext &context, TableFunctionInput &data_p,
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
 		auto &entry = data.entries[data.offset++];
 
-		auto &attached = entry->Cast<AttachedDatabase>();
+		auto &attached = entry.get().Cast<AttachedDatabase>();
 		// return values:
 
 		idx_t col = 0;

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

@@ -21,7 +21,7 @@ struct DuckDBFunctionsData : public GlobalTableFunctionState {
 	DuckDBFunctionsData() : offset(0), offset_in_entry(0) {
 	}
 
-	vector<CatalogEntry *> entries;
+	vector<reference<CatalogEntry>> entries;
 	idx_t offset;
 	idx_t offset_in_entry;
 };
@@ -73,24 +73,26 @@ static unique_ptr<FunctionData> DuckDBFunctionsBind(ClientContext &context, Tabl
 static void ExtractFunctionsFromSchema(ClientContext &context, SchemaCatalogEntry &schema,
                                        DuckDBFunctionsData &result) {
 	schema.Scan(context, CatalogType::SCALAR_FUNCTION_ENTRY,
-	            [&](CatalogEntry *entry) { result.entries.push_back(entry); });
+	            [&](CatalogEntry &entry) { result.entries.push_back(entry); });
 	schema.Scan(context, CatalogType::TABLE_FUNCTION_ENTRY,
-	            [&](CatalogEntry *entry) { result.entries.push_back(entry); });
+	            [&](CatalogEntry &entry) { result.entries.push_back(entry); });
 	schema.Scan(context, CatalogType::PRAGMA_FUNCTION_ENTRY,
-	            [&](CatalogEntry *entry) { result.entries.push_back(entry); });
+	            [&](CatalogEntry &entry) { result.entries.push_back(entry); });
 }
 
 unique_ptr<GlobalTableFunctionState> DuckDBFunctionsInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_uniq<DuckDBFunctionsData>();
 
-	// scan all the schemas for tables and collect themand collect them
+	// scan all the schemas for tables and collect them and collect them
 	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto &schema : schemas) {
-		ExtractFunctionsFromSchema(context, *schema, *result);
+		ExtractFunctionsFromSchema(context, schema.get(), *result);
 	};
 
 	std::sort(result->entries.begin(), result->entries.end(),
-	          [&](CatalogEntry *a, CatalogEntry *b) { return (int)a->type < (int)b->type; });
+	          [&](reference<CatalogEntry> a, reference<CatalogEntry> b) {
+		          return (int32_t)a.get().type < (int32_t)b.get().type;
+	          });
 	return std::move(result);
 }
 
@@ -420,18 +422,18 @@ struct PragmaFunctionExtractor {
 };
 
 template <class T, class OP>
-bool ExtractFunctionData(StandardEntry *entry, idx_t function_idx, DataChunk &output, idx_t output_offset) {
-	auto &function = (T &)*entry;
+bool ExtractFunctionData(CatalogEntry &entry, idx_t function_idx, DataChunk &output, idx_t output_offset) {
+	auto &function = entry.Cast<T>();
 	idx_t col = 0;
 
 	// database_name, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, Value(entry->schema->catalog->GetName()));
+	output.SetValue(col++, output_offset, Value(function.schema.catalog.GetName()));
 
 	// schema_name, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, Value(entry->schema->name));
+	output.SetValue(col++, output_offset, Value(function.schema.name));
 
 	// function_name, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, Value(entry->name));
+	output.SetValue(col++, output_offset, Value(function.name));
 
 	// function_type, LogicalType::VARCHAR
 	output.SetValue(col++, output_offset, Value(OP::GetFunctionType()));
@@ -458,10 +460,10 @@ bool ExtractFunctionData(StandardEntry *entry, idx_t function_idx, DataChunk &ou
 	output.SetValue(col++, output_offset, OP::HasSideEffects(function, function_idx));
 
 	// internal, LogicalType::BOOLEAN
-	output.SetValue(col++, output_offset, Value::BOOLEAN(entry->internal));
+	output.SetValue(col++, output_offset, Value::BOOLEAN(function.internal));
 
 	// function_oid, LogicalType::BIGINT
-	output.SetValue(col++, output_offset, Value::BIGINT(entry->oid));
+	output.SetValue(col++, output_offset, Value::BIGINT(function.oid));
 
 	return function_idx + 1 == OP::FunctionCount(function);
 }
@@ -476,35 +478,34 @@ void DuckDBFunctionsFunction(ClientContext &context, TableFunctionInput &data_p,
 	// 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 standard_entry = (StandardEntry *)entry;
+		auto &entry = data.entries[data.offset].get();
 		bool finished;
 
-		switch (entry->type) {
+		switch (entry.type) {
 		case CatalogType::SCALAR_FUNCTION_ENTRY:
 			finished = ExtractFunctionData<ScalarFunctionCatalogEntry, ScalarFunctionExtractor>(
-			    standard_entry, data.offset_in_entry, output, count);
+			    entry, data.offset_in_entry, output, count);
 			break;
 		case CatalogType::AGGREGATE_FUNCTION_ENTRY:
 			finished = ExtractFunctionData<AggregateFunctionCatalogEntry, AggregateFunctionExtractor>(
-			    standard_entry, data.offset_in_entry, output, count);
+			    entry, data.offset_in_entry, output, count);
 			break;
 		case CatalogType::TABLE_MACRO_ENTRY:
-			finished = ExtractFunctionData<TableMacroCatalogEntry, TableMacroExtractor>(
-			    standard_entry, data.offset_in_entry, output, count);
+			finished = ExtractFunctionData<TableMacroCatalogEntry, TableMacroExtractor>(entry, data.offset_in_entry,
+			                                                                            output, count);
 			break;
 
 		case CatalogType::MACRO_ENTRY:
-			finished = ExtractFunctionData<ScalarMacroCatalogEntry, MacroExtractor>(
-			    standard_entry, data.offset_in_entry, output, count);
+			finished = ExtractFunctionData<ScalarMacroCatalogEntry, MacroExtractor>(entry, data.offset_in_entry, output,
+			                                                                        count);
 			break;
 		case CatalogType::TABLE_FUNCTION_ENTRY:
 			finished = ExtractFunctionData<TableFunctionCatalogEntry, TableFunctionExtractor>(
-			    standard_entry, data.offset_in_entry, output, count);
+			    entry, data.offset_in_entry, output, count);
 			break;
 		case CatalogType::PRAGMA_FUNCTION_ENTRY:
 			finished = ExtractFunctionData<PragmaFunctionCatalogEntry, PragmaFunctionExtractor>(
-			    standard_entry, data.offset_in_entry, output, count);
+			    entry, data.offset_in_entry, output, count);
 			break;
 		default:
 			throw InternalException("FIXME: unrecognized function type in duckdb_functions");

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

@@ -15,7 +15,7 @@ struct DuckDBIndexesData : public GlobalTableFunctionState {
 	DuckDBIndexesData() : offset(0) {
 	}
 
-	vector<CatalogEntry *> entries;
+	vector<reference<CatalogEntry>> entries;
 	idx_t offset;
 };
 
@@ -66,7 +66,8 @@ unique_ptr<GlobalTableFunctionState> DuckDBIndexesInit(ClientContext &context, T
 	// 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::INDEX_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
+		schema.get().Scan(context, CatalogType::INDEX_ENTRY,
+		                  [&](CatalogEntry &entry) { result->entries.push_back(entry); });
 	};
 	return std::move(result);
 }
@@ -81,31 +82,31 @@ void DuckDBIndexesFunction(ClientContext &context, TableFunctionInput &data_p, D
 	// 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();
 
-		auto &index = entry->Cast<IndexCatalogEntry>();
+		auto &index = entry.Cast<IndexCatalogEntry>();
 		// return values:
 
 		idx_t col = 0;
 		// database_name, VARCHAR
-		output.SetValue(col++, count, index.catalog->GetName());
+		output.SetValue(col++, count, index.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(index.catalog->GetOid()));
+		output.SetValue(col++, count, Value::BIGINT(index.catalog.GetOid()));
 		// schema_name, VARCHAR
-		output.SetValue(col++, count, Value(index.schema->name));
+		output.SetValue(col++, count, Value(index.schema.name));
 		// schema_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(index.schema->oid));
+		output.SetValue(col++, count, Value::BIGINT(index.schema.oid));
 		// index_name, VARCHAR
 		output.SetValue(col++, count, Value(index.name));
 		// index_oid, BIGINT
 		output.SetValue(col++, count, Value::BIGINT(index.oid));
 		// find the table in the catalog
-		auto table_entry =
-		    index.schema->catalog->GetEntry<TableCatalogEntry>(context, index.GetSchemaName(), index.GetTableName());
+		auto &table_entry =
+		    index.schema.catalog.GetEntry<TableCatalogEntry>(context, index.GetSchemaName(), index.GetTableName());
 		// table_name, VARCHAR
-		output.SetValue(col++, count, Value(table_entry->name));
+		output.SetValue(col++, count, Value(table_entry.name));
 		// table_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(table_entry->oid));
+		output.SetValue(col++, count, Value::BIGINT(table_entry.oid));
 		if (index.index) {
 			// is_unique, BOOLEAN
 			output.SetValue(col++, count, Value::BOOLEAN(index.index->IsUnique()));

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

@@ -12,7 +12,7 @@ struct DuckDBSchemasData : public GlobalTableFunctionState {
 	DuckDBSchemasData() : offset(0) {
 	}
 
-	vector<SchemaCatalogEntry *> entries;
+	vector<reference<SchemaCatalogEntry>> entries;
 	idx_t offset;
 };
 
@@ -58,20 +58,20 @@ void DuckDBSchemasFunction(ClientContext &context, TableFunctionInput &data_p, D
 	// 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();
 
 		// return values:
 		idx_t col = 0;
 		// "oid", PhysicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(entry->oid));
+		output.SetValue(col++, count, Value::BIGINT(entry.oid));
 		// database_name, VARCHAR
-		output.SetValue(col++, count, entry->catalog->GetName());
+		output.SetValue(col++, count, entry.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(entry->catalog->GetOid()));
+		output.SetValue(col++, count, Value::BIGINT(entry.catalog.GetOid()));
 		// "schema_name", PhysicalType::VARCHAR
-		output.SetValue(col++, count, Value(entry->name));
+		output.SetValue(col++, count, Value(entry.name));
 		// "internal", PhysicalType::BOOLEAN
-		output.SetValue(col++, count, Value::BOOLEAN(entry->internal));
+		output.SetValue(col++, count, Value::BOOLEAN(entry.internal));
 		// "sql", PhysicalType::VARCHAR
 		output.SetValue(col++, count, Value());
 

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

@@ -13,7 +13,7 @@ struct DuckDBSequencesData : public GlobalTableFunctionState {
 	DuckDBSequencesData() : offset(0) {
 	}
 
-	vector<SequenceCatalogEntry *> entries;
+	vector<reference<SequenceCatalogEntry>> entries;
 	idx_t offset;
 };
 
@@ -70,8 +70,8 @@ unique_ptr<GlobalTableFunctionState> DuckDBSequencesInit(ClientContext &context,
 	// scan all the schemas for tables and collect themand collect them
 	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::SEQUENCE_ENTRY,
-		             [&](CatalogEntry *entry) { result->entries.push_back((SequenceCatalogEntry *)entry); });
+		schema.get().Scan(context, CatalogType::SEQUENCE_ENTRY,
+		                  [&](CatalogEntry &entry) { result->entries.push_back(entry.Cast<SequenceCatalogEntry>()); });
 	};
 	return std::move(result);
 }
@@ -86,19 +86,18 @@ void DuckDBSequencesFunction(ClientContext &context, TableFunctionInput &data_p,
 	// 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 &seq = data.entries[data.offset++].get();
 
-		auto &seq = entry->Cast<SequenceCatalogEntry>();
 		// return values:
 		idx_t col = 0;
 		// database_name, VARCHAR
-		output.SetValue(col++, count, entry->catalog->GetName());
+		output.SetValue(col++, count, seq.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(entry->catalog->GetOid()));
+		output.SetValue(col++, count, Value::BIGINT(seq.catalog.GetOid()));
 		// schema_name, VARCHAR
-		output.SetValue(col++, count, Value(seq.schema->name));
+		output.SetValue(col++, count, Value(seq.schema.name));
 		// schema_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(seq.schema->oid));
+		output.SetValue(col++, count, Value::BIGINT(seq.schema.oid));
 		// sequence_name, VARCHAR
 		output.SetValue(col++, count, Value(seq.name));
 		// sequence_oid, BIGINT