duckdb 0.7.2-dev1803.0 → 0.7.2-dev1898.0

package/src/duckdb/src/function/scalar/string/damerau_levenshtein.cpp

@@ -0,0 +1,106 @@
+#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/common/map.hpp"
+#include "duckdb/common/vector.hpp"
+
+namespace duckdb {
+
+// Using Lowrance-Wagner (LW) algorithm: https://doi.org/10.1145%2F321879.321880
+// Can't calculate as trivial modification to levenshtein algorithm
+// as we need to potentially know about earlier in the string
+static idx_t DamerauLevenshteinDistance(const string_t &source, const string_t &target) {
+	// costs associated with each type of edit, to aid readability
+	constexpr uint8_t COST_SUBSTITUTION = 1;
+	constexpr uint8_t COST_INSERTION = 1;
+	constexpr uint8_t COST_DELETION = 1;
+	constexpr uint8_t COST_TRANSPOSITION = 1;
+	const auto source_len = source.GetSize();
+	const auto target_len = target.GetSize();
+
+	// If one string is empty, the distance equals the length of the other string
+	// either through target_len insertions
+	// or source_len deletions
+	if (source_len == 0) {
+		return target_len * COST_INSERTION;
+	} else if (target_len == 0) {
+		return source_len * COST_DELETION;
+	}
+
+	const auto source_str = source.GetDataUnsafe();
+	const auto target_str = target.GetDataUnsafe();
+
+	// larger than the largest possible value:
+	const auto inf = source_len * COST_DELETION + target_len * COST_INSERTION + 1;
+	// minimum edit distance from prefix of source string to prefix of target string
+	// same object as H in LW paper (with indices offset by 1)
+	vector<vector<idx_t>> distance(source_len + 2, vector<idx_t>(target_len + 2, inf));
+	// keeps track of the largest string indices of source string matching each character
+	// same as DA in LW paper
+	map<char, idx_t> largest_source_chr_matching;
+
+	// initialise row/column corresponding to zero-length strings
+	// partial string -> empty requires a deletion for each character
+	for (idx_t source_idx = 0; source_idx <= source_len; source_idx++) {
+		distance[source_idx + 1][1] = source_idx * COST_DELETION;
+	}
+	// and empty -> partial string means simply inserting characters
+	for (idx_t target_idx = 1; target_idx <= target_len; target_idx++) {
+		distance[1][target_idx + 1] = target_idx * COST_INSERTION;
+	}
+	// loop through string indices - these are offset by 2 from distance indices
+	for (idx_t source_idx = 0; source_idx < source_len; source_idx++) {
+		// keeps track of the largest string indices of target string matching current source character
+		// same as DB in LW paper
+		idx_t largest_target_chr_matching;
+		largest_target_chr_matching = 0;
+		for (idx_t target_idx = 0; target_idx < target_len; target_idx++) {
+			// correspond to i1 and j1 in LW paper respectively
+			idx_t largest_source_chr_matching_target;
+			idx_t largest_target_chr_matching_source;
+			// cost associated to diagnanl shift in distance matrix
+			// corresponds to d in LW paper
+			uint8_t cost_diagonal_shift;
+			largest_source_chr_matching_target = largest_source_chr_matching[target_str[target_idx]];
+			largest_target_chr_matching_source = largest_target_chr_matching;
+			// if characters match, diagonal move costs nothing and we update our largest target index
+			// otherwise move is substitution and costs as such
+			if (source_str[source_idx] == target_str[target_idx]) {
+				cost_diagonal_shift = 0;
+				largest_target_chr_matching = target_idx + 1;
+			} else {
+				cost_diagonal_shift = COST_SUBSTITUTION;
+			}
+			distance[source_idx + 2][target_idx + 2] = MinValue(
+			    distance[source_idx + 1][target_idx + 1] + cost_diagonal_shift,
+			    MinValue(distance[source_idx + 2][target_idx + 1] + COST_INSERTION,
+			             MinValue(distance[source_idx + 1][target_idx + 2] + COST_DELETION,
+			                      distance[largest_source_chr_matching_target][largest_target_chr_matching_source] +
+			                          (source_idx - largest_source_chr_matching_target) * COST_DELETION +
+			                          COST_TRANSPOSITION +
+			                          (target_idx - largest_target_chr_matching_source) * COST_INSERTION)));
+		}
+		largest_source_chr_matching[source_str[source_idx]] = source_idx + 1;
+	}
+	return distance[source_len + 1][target_len + 1];
+}
+
+static int64_t DamerauLevenshteinScalarFunction(Vector &result, const string_t source, const string_t target) {
+	return (int64_t)DamerauLevenshteinDistance(source, target);
+}
+
+static void DamerauLevenshteinFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &source_vec = args.data[0];
+	auto &target_vec = args.data[1];
+
+	BinaryExecutor::Execute<string_t, string_t, int64_t>(
+	    source_vec, target_vec, result, args.size(),
+	    [&](string_t source, string_t target) { return DamerauLevenshteinScalarFunction(result, source, target); });
+}
+
+void DamerauLevenshteinFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet damerau_levenshtein("damerau_levenshtein");
+	damerau_levenshtein.AddFunction(ScalarFunction("damerau_levenshtein", {LogicalType::VARCHAR, LogicalType::VARCHAR},
+	                                               LogicalType::BIGINT, DamerauLevenshteinFunction));
+	set.AddFunction(damerau_levenshtein);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/string/regexp.cpp

@@ -218,6 +218,103 @@ bool RegexpExtractBindData::Equals(const FunctionData &other_p) const {
 	return RegexpBaseBindData::Equals(other) && group_string == other.group_string;
 }
 
+static void RegexExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	const auto &info = func_expr.bind_info->Cast<RegexpExtractBindData>();
+
+	auto &strings = args.data[0];
+	auto &patterns = args.data[1];
+	if (info.constant_pattern) {
+		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
+		UnaryExecutor::Execute<string_t, string_t>(strings, result, args.size(), [&](string_t input) {
+			return Extract(input, result, lstate.constant_pattern, info.rewrite);
+		});
+	} else {
+		BinaryExecutor::Execute<string_t, string_t, string_t>(strings, patterns, result, args.size(),
+		                                                      [&](string_t input, string_t pattern) {
+			                                                      RE2 re(CreateStringPiece(pattern), info.options);
+			                                                      return Extract(input, result, re, info.rewrite);
+		                                                      });
+	}
+}
+
+//===--------------------------------------------------------------------===//
+// Regexp Extract Struct
+//===--------------------------------------------------------------------===//
+static void RegexExtractStructFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
+
+	const auto count = args.size();
+	auto &input = args.data[0];
+
+	auto &child_entries = StructVector::GetEntries(result);
+	const auto groupSize = child_entries.size();
+	// Reference the 'input' StringBuffer, because we won't need to allocate new data
+	// for the result, all returned strings are substrings of the originals
+	for (auto &child_entry : child_entries) {
+		child_entry->SetAuxiliary(input.GetAuxiliary());
+	}
+
+	vector<RE2::Arg> argv(groupSize);
+	vector<RE2::Arg *> groups(groupSize);
+	vector<duckdb_re2::StringPiece> ws(groupSize);
+	for (size_t i = 0; i < groupSize; ++i) {
+		groups[i] = &argv[i];
+		argv[i] = &ws[i];
+	}
+
+	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+
+		if (ConstantVector::IsNull(input)) {
+			ConstantVector::SetNull(result, true);
+		} else {
+			ConstantVector::SetNull(result, false);
+			auto idata = ConstantVector::GetData<string_t>(input);
+			auto str = CreateStringPiece(idata[0]);
+			auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(), groups.size());
+			for (size_t col = 0; col < child_entries.size(); ++col) {
+				auto &child_entry = child_entries[col];
+				ConstantVector::SetNull(*child_entry, false);
+				auto &extracted = ws[col];
+				auto cdata = ConstantVector::GetData<string_t>(*child_entry);
+				cdata[0] = string_t(extracted.data(), match ? extracted.size() : 0);
+			}
+		}
+	} else {
+		UnifiedVectorFormat iunified;
+		input.ToUnifiedFormat(count, iunified);
+
+		const auto &ivalidity = iunified.validity;
+		auto idata = (const string_t *)iunified.data;
+
+		// Start with a valid flat vector
+		result.SetVectorType(VectorType::FLAT_VECTOR);
+
+		// Start with valid children
+		for (size_t col = 0; col < child_entries.size(); ++col) {
+			auto &child_entry = child_entries[col];
+			child_entry->SetVectorType(VectorType::FLAT_VECTOR);
+		}
+
+		for (idx_t i = 0; i < count; ++i) {
+			const auto idx = iunified.sel->get_index(i);
+			if (ivalidity.RowIsValid(idx)) {
+				auto str = CreateStringPiece(idata[idx]);
+				auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(), groups.size());
+				for (size_t col = 0; col < child_entries.size(); ++col) {
+					auto &child_entry = child_entries[col];
+					auto cdata = FlatVector::GetData<string_t>(*child_entry);
+					auto &extracted = ws[col];
+					cdata[i] = string_t(extracted.data(), match ? extracted.size() : 0);
+				}
+			} else {
+				FlatVector::SetNull(result, i, true);
+			}
+		}
+	}
+}
+
 static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarFunction &bound_function,
                                                  vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(arguments.size() >= 2);
@@ -227,52 +324,62 @@ static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarF
 	string constant_string;
 	bool constant_pattern = TryParseConstantPattern(context, *arguments[1], constant_string);
 
-	string group_string = "";
+	if (arguments.size() >= 4) {
+		ParseRegexOptions(context, *arguments[3], options);
+	}
+
+	string group_string = "\\0";
 	if (arguments.size() >= 3) {
 		if (arguments[2]->HasParameter()) {
 			throw ParameterNotResolvedException();
 		}
 		if (!arguments[2]->IsFoldable()) {
-			throw InvalidInputException("Group index field field must be a constant!");
+			throw InvalidInputException("Group specification field must be a constant!");
 		}
 		Value group = ExpressionExecutor::EvaluateScalar(context, *arguments[2]);
-		if (!group.IsNull()) {
+		if (group.IsNull()) {
+			group_string = "";
+		} else if (group.type().id() == LogicalTypeId::LIST) {
+			if (!constant_pattern) {
+				throw BinderException("%s with LIST requires a constant pattern", bound_function.name);
+			}
+			auto &list_children = ListValue::GetChildren(group);
+			if (list_children.empty()) {
+				throw BinderException("%s requires non-empty lists of capture names", bound_function.name);
+			}
+			case_insensitive_set_t name_collision_set;
+			child_list_t<LogicalType> struct_children;
+			for (const auto &child : list_children) {
+				if (child.IsNull()) {
+					throw BinderException("NULL group name in %s", bound_function.name);
+				}
+				const auto group_name = child.ToString();
+				if (name_collision_set.find(group_name) != name_collision_set.end()) {
+					throw BinderException("Duplicate group name \"%s\" in %s", group_name, bound_function.name);
+				}
+				name_collision_set.insert(group_name);
+				struct_children.emplace_back(make_pair(group_name, LogicalType::VARCHAR));
+			}
+			bound_function.return_type = LogicalType::STRUCT(struct_children);
+
+			duckdb_re2::StringPiece constant_piece(constant_string.c_str(), constant_string.size());
+			RE2 constant_pattern(constant_piece, options);
+			if (size_t(constant_pattern.NumberOfCapturingGroups()) < list_children.size()) {
+				throw BinderException("Not enough group names in %s", bound_function.name);
+			}
+		} else {
 			auto group_idx = group.GetValue<int32_t>();
 			if (group_idx < 0 || group_idx > 9) {
 				throw InvalidInputException("Group index must be between 0 and 9!");
 			}
 			group_string = "\\" + to_string(group_idx);
 		}
-	} else {
-		group_string = "\\0";
-	}
-	if (arguments.size() >= 4) {
-		ParseRegexOptions(context, *arguments[3], options);
 	}
+
 	return make_uniq<RegexpExtractBindData>(options, std::move(constant_string), constant_pattern,
 	                                        std::move(group_string));
 }
 
-static void RegexExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	const auto &info = func_expr.bind_info->Cast<RegexpExtractBindData>();
-
-	auto &strings = args.data[0];
-	auto &patterns = args.data[1];
-	if (info.constant_pattern) {
-		auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RegexLocalState>();
-		UnaryExecutor::Execute<string_t, string_t>(strings, result, args.size(), [&](string_t input) {
-			return Extract(input, result, lstate.constant_pattern, info.rewrite);
-		});
-	} else {
-		BinaryExecutor::Execute<string_t, string_t, string_t>(strings, patterns, result, args.size(),
-		                                                      [&](string_t input, string_t pattern) {
-			                                                      RE2 re(CreateStringPiece(pattern), info.options);
-			                                                      return Extract(input, result, re, info.rewrite);
-		                                                      });
-	}
-}
-
 void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet regexp_full_match("regexp_full_match");
 	regexp_full_match.AddFunction(ScalarFunction(
@@ -315,6 +422,16 @@ void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	    RegexExtractFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
 	    FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	// REGEXP_EXTRACT(<string>, <pattern>, [<group 1 name>[, <group n name>]...])
+	regexp_extract.AddFunction(ScalarFunction(
+	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::LIST(LogicalType::VARCHAR)}, LogicalType::VARCHAR,
+	    RegexExtractStructFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
+	    FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
+	// REGEXP_EXTRACT(<string>, <pattern>, [<group 1 name>[, <group n name>]...], <options>)
+	regexp_extract.AddFunction(ScalarFunction(
+	    {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::LIST(LogicalType::VARCHAR), LogicalType::VARCHAR},
+	    LogicalType::VARCHAR, RegexExtractStructFunction, RegexExtractBind, nullptr, nullptr, RegexInitLocalState,
+	    LogicalType::INVALID, FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING));
 
 	ScalarFunctionSet regexp_extract_all("regexp_extract_all");
 	regexp_extract_all.AddFunction(ScalarFunction(

package/src/duckdb/src/function/scalar/string_functions.cpp

@@ -39,6 +39,7 @@ void BuiltinFunctions::RegisterStringFunctions() {
 	Register<CHR>();
 	Register<MismatchesFun>();
 	Register<LevenshteinFun>();
+	Register<DamerauLevenshteinFun>();
 	Register<JaccardFun>();
 	Register<JaroWinklerFun>();
 

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

@@ -8,10 +8,10 @@
 namespace duckdb {
 
 struct CheckpointBindData : public FunctionData {
-	explicit CheckpointBindData(AttachedDatabase *db) : db(db) {
+	explicit CheckpointBindData(optional_ptr<AttachedDatabase> db) : db(db) {
 	}
 
-	AttachedDatabase *db;
+	optional_ptr<AttachedDatabase> db;
 
 public:
 	unique_ptr<FunctionData> Copy() const override {
@@ -29,7 +29,7 @@ static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, TableFunc
 	return_types.emplace_back(LogicalType::BOOLEAN);
 	names.emplace_back("Success");
 
-	AttachedDatabase *db;
+	optional_ptr<AttachedDatabase> db;
 	auto &db_manager = DatabaseManager::Get(context);
 	if (!input.inputs.empty()) {
 		auto &db_name = StringValue::Get(input.inputs[0]);
@@ -46,7 +46,7 @@ static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, TableFunc
 template <bool FORCE>
 static void TemplatedCheckpointFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = data_p.bind_data->Cast<CheckpointBindData>();
-	auto &transaction_manager = TransactionManager::Get(*bind_data.db);
+	auto &transaction_manager = TransactionManager::Get(*bind_data.db.get_mutable());
 	transaction_manager.Checkpoint(context, FORCE);
 }
 

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<CatalogEntry *> entries;
+	vector<optional_ptr<CatalogEntry>> entries;
 	idx_t offset;
 	idx_t column_offset;
 };
@@ -90,12 +90,12 @@ unique_ptr<GlobalTableFunctionState> DuckDBColumnsInit(ClientContext &context, T
 
 class ColumnHelper {
 public:
-	static unique_ptr<ColumnHelper> Create(CatalogEntry *entry);
+	static unique_ptr<ColumnHelper> Create(CatalogEntry &entry);
 
 	virtual ~ColumnHelper() {
 	}
 
-	virtual StandardEntry *Entry() = 0;
+	virtual StandardEntry &Entry() = 0;
 	virtual idx_t NumColumns() = 0;
 	virtual const string &ColumnName(idx_t col) = 0;
 	virtual const LogicalType &ColumnType(idx_t col) = 0;
@@ -107,8 +107,8 @@ public:
 
 class TableColumnHelper : public ColumnHelper {
 public:
-	explicit TableColumnHelper(TableCatalogEntry *entry) : entry(entry) {
-		for (auto &constraint : entry->GetConstraints()) {
+	explicit TableColumnHelper(TableCatalogEntry &entry) : entry(entry) {
+		for (auto &constraint : entry.GetConstraints()) {
 			if (constraint->type == ConstraintType::NOT_NULL) {
 				auto &not_null = *reinterpret_cast<NotNullConstraint *>(constraint.get());
 				not_null_cols.insert(not_null.index.index);
@@ -116,20 +116,20 @@ public:
 		}
 	}
 
-	StandardEntry *Entry() override {
+	StandardEntry &Entry() override {
 		return entry;
 	}
 	idx_t NumColumns() override {
-		return entry->GetColumns().LogicalColumnCount();
+		return entry.GetColumns().LogicalColumnCount();
 	}
 	const string &ColumnName(idx_t col) override {
-		return entry->GetColumn(LogicalIndex(col)).Name();
+		return entry.GetColumn(LogicalIndex(col)).Name();
 	}
 	const LogicalType &ColumnType(idx_t col) override {
-		return entry->GetColumn(LogicalIndex(col)).Type();
+		return entry.GetColumn(LogicalIndex(col)).Type();
 	}
 	const Value ColumnDefault(idx_t col) override {
-		auto &column = entry->GetColumn(LogicalIndex(col));
+		auto &column = entry.GetColumn(LogicalIndex(col));
 		if (column.DefaultValue()) {
 			return Value(column.DefaultValue()->ToString());
 		}
@@ -140,26 +140,26 @@ public:
 	}
 
 private:
-	TableCatalogEntry *entry;
+	TableCatalogEntry &entry;
 	std::set<idx_t> not_null_cols;
 };
 
 class ViewColumnHelper : public ColumnHelper {
 public:
-	explicit ViewColumnHelper(ViewCatalogEntry *entry) : entry(entry) {
+	explicit ViewColumnHelper(ViewCatalogEntry &entry) : entry(entry) {
 	}
 
-	StandardEntry *Entry() override {
+	StandardEntry &Entry() override {
 		return entry;
 	}
 	idx_t NumColumns() override {
-		return entry->types.size();
+		return entry.types.size();
 	}
 	const string &ColumnName(idx_t col) override {
-		return entry->aliases[col];
+		return entry.aliases[col];
 	}
 	const LogicalType &ColumnType(idx_t col) override {
-		return entry->types[col];
+		return entry.types[col];
 	}
 	const Value ColumnDefault(idx_t col) override {
 		return Value();
@@ -169,15 +169,15 @@ public:
 	}
 
 private:
-	ViewCatalogEntry *entry;
+	ViewCatalogEntry &entry;
 };
 
-unique_ptr<ColumnHelper> ColumnHelper::Create(CatalogEntry *entry) {
-	switch (entry->type) {
+unique_ptr<ColumnHelper> ColumnHelper::Create(CatalogEntry &entry) {
+	switch (entry.type) {
 	case CatalogType::TABLE_ENTRY:
-		return make_uniq<TableColumnHelper>((TableCatalogEntry *)entry);
+		return make_uniq<TableColumnHelper>(entry.Cast<TableCatalogEntry>());
 	case CatalogType::VIEW_ENTRY:
-		return make_uniq<ViewColumnHelper>((ViewCatalogEntry *)entry);
+		return make_uniq<ViewColumnHelper>(entry.Cast<ViewCatalogEntry>());
 	default:
 		throw NotImplementedException("Unsupported catalog type for duckdb_columns");
 	}
@@ -186,7 +186,7 @@ unique_ptr<ColumnHelper> ColumnHelper::Create(CatalogEntry *entry) {
 void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_col, DataChunk &output) {
 	for (idx_t i = start_col; i < end_col; i++) {
 		auto index = start_index + (i - start_col);
-		auto &entry = *Entry();
+		auto &entry = Entry();
 
 		idx_t col = 0;
 		// database_name, VARCHAR
@@ -284,7 +284,7 @@ void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_co
 }
 
 void DuckDBColumnsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBColumnsData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<DuckDBColumnsData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -298,7 +298,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]);
 		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

@@ -19,7 +19,8 @@
 namespace duckdb {
 
 struct UniqueKeyInfo {
-	string schema, table;
+	string schema;
+	string table;
 	vector<LogicalIndex> columns;
 
 	bool operator==(const UniqueKeyInfo &other) const {
@@ -52,7 +53,7 @@ struct DuckDBConstraintsData : public GlobalTableFunctionState {
 	DuckDBConstraintsData() : offset(0), constraint_offset(0), unique_constraint_offset(0) {
 	}
 
-	vector<CatalogEntry *> entries;
+	vector<optional_ptr<CatalogEntry>> entries;
 	idx_t offset;
 	idx_t constraint_offset;
 	idx_t unique_constraint_offset;
@@ -125,7 +126,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBConstraintsInit(ClientContext &contex
 }
 
 void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBConstraintsData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<DuckDBConstraintsData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -134,10 +135,10 @@ 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];
-		D_ASSERT(entry->type == CatalogType::TABLE_ENTRY);
+		auto &entry = *data.entries[data.offset];
+		D_ASSERT(entry.type == CatalogType::TABLE_ENTRY);
 
-		auto &table = entry->Cast<TableCatalogEntry>();
+		auto &table = entry.Cast<TableCatalogEntry>();
 		auto &constraints = table.GetConstraints();
 		bool is_duck_table = table.IsDuckTable();
 		for (; data.constraint_offset < constraints.size() && count < STANDARD_VECTOR_SIZE; data.constraint_offset++) {

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

@@ -8,7 +8,7 @@ struct DuckDBDatabasesData : public GlobalTableFunctionState {
 	DuckDBDatabasesData() : offset(0) {
 	}
 
-	vector<AttachedDatabase *> entries;
+	vector<optional_ptr<AttachedDatabase>> entries;
 	idx_t offset;
 };
 

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

@@ -9,8 +9,12 @@
 namespace duckdb {
 
 struct DependencyInformation {
-	CatalogEntry *object;
-	CatalogEntry *dependent;
+	DependencyInformation(CatalogEntry &object, CatalogEntry &dependent, DependencyType type)
+	    : object(object), dependent(dependent), type(type) {
+	}
+
+	CatalogEntry &object;
+	CatalogEntry &dependent;
 	DependencyType type;
 };
 
@@ -54,14 +58,10 @@ unique_ptr<GlobalTableFunctionState> DuckDBDependenciesInit(ClientContext &conte
 	// scan all the schemas and collect them
 	auto &catalog = Catalog::GetCatalog(context, INVALID_CATALOG);
 	if (catalog.IsDuckCatalog()) {
-		auto &duck_catalog = (DuckCatalog &)catalog;
+		auto &duck_catalog = catalog.Cast<DuckCatalog>();
 		auto &dependency_manager = duck_catalog.GetDependencyManager();
-		dependency_manager.Scan([&](CatalogEntry *obj, CatalogEntry *dependent, DependencyType type) {
-			DependencyInformation info;
-			info.object = obj;
-			info.dependent = dependent;
-			info.type = type;
-			result->entries.push_back(info);
+		dependency_manager.Scan([&](CatalogEntry &obj, CatalogEntry &dependent, DependencyType type) {
+			result->entries.emplace_back(obj, dependent, type);
 		});
 	}
 
@@ -84,13 +84,13 @@ void DuckDBDependenciesFunction(ClientContext &context, TableFunctionInput &data
 		// classid, LogicalType::BIGINT
 		output.SetValue(0, count, Value::BIGINT(0));
 		// objid, LogicalType::BIGINT
-		output.SetValue(1, count, Value::BIGINT(entry.object->oid));
+		output.SetValue(1, count, Value::BIGINT(entry.object.oid));
 		// objsubid, LogicalType::INTEGER
 		output.SetValue(2, count, Value::INTEGER(0));
 		// refclassid, LogicalType::BIGINT
 		output.SetValue(3, count, Value::BIGINT(0));
 		// refobjid, LogicalType::BIGINT
-		output.SetValue(4, count, Value::BIGINT(entry.dependent->oid));
+		output.SetValue(4, count, Value::BIGINT(entry.dependent.oid));
 		// refobjsubid, LogicalType::INTEGER
 		output.SetValue(5, count, Value::INTEGER(0));
 		// deptype, LogicalType::VARCHAR

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

@@ -15,7 +15,7 @@ struct PragmaDatabaseSizeData : public GlobalTableFunctionState {
 	}
 
 	idx_t index;
-	vector<AttachedDatabase *> databases;
+	vector<optional_ptr<AttachedDatabase>> databases;
 	Value memory_usage;
 	Value memory_limit;
 };