duckdb 1.3.4 → 1.4.1-dev2.0

package/src/duckdb/src/function/macro_function.cpp

@@ -1,4 +1,3 @@
-
 #include "duckdb/function/macro_function.hpp"
 
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
@@ -9,111 +8,256 @@
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/parser/expression/cast_expression.hpp"
+#include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
 
 namespace duckdb {
 
 MacroFunction::MacroFunction(MacroType type) : type(type) {
 }
 
-string FormatMacroFunction(MacroFunction &function, const string &name) {
-	string result;
-	result = name + "(";
+string FormatMacroFunction(const MacroFunction &function, const string &name) {
+	auto result = name + "(";
 	string parameters;
-	for (auto &param : function.parameters) {
+	for (idx_t param_idx = 0; param_idx < function.parameters.size(); param_idx++) {
 		if (!parameters.empty()) {
 			parameters += ", ";
 		}
-		parameters += param->Cast<ColumnRefExpression>().GetColumnName();
-	}
-	for (auto &named_param : function.default_parameters) {
-		if (!parameters.empty()) {
-			parameters += ", ";
+		const auto &param_name = function.parameters[param_idx]->Cast<ColumnRefExpression>().GetColumnName();
+		parameters += param_name;
+
+		if (!function.types.empty() && function.types[param_idx] != LogicalType::UNKNOWN) {
+			parameters += " " + function.types[param_idx].ToString();
+		}
+
+		auto it = function.default_parameters.find(param_name);
+		if (it != function.default_parameters.end()) {
+			parameters += " := ";
+			parameters += it->second->ToString();
 		}
-		parameters += named_param.first;
-		parameters += " := ";
-		parameters += named_param.second->ToString();
 	}
 	result += parameters + ")";
 	return result;
 }
 
-MacroBindResult MacroFunction::BindMacroFunction(const vector<unique_ptr<MacroFunction>> &functions, const string &name,
-                                                 FunctionExpression &function_expr,
-                                                 vector<unique_ptr<ParsedExpression>> &positionals,
-                                                 unordered_map<string, unique_ptr<ParsedExpression>> &defaults) {
-	// separate positional and default arguments
+MacroBindResult MacroFunction::BindMacroFunction(
+    Binder &binder, const vector<unique_ptr<MacroFunction>> &functions, const string &name,
+    FunctionExpression &function_expr, vector<unique_ptr<ParsedExpression>> &positional_arguments,
+    InsertionOrderPreservingMap<unique_ptr<ParsedExpression>> &named_arguments, idx_t depth) {
+
+	ExpressionBinder expr_binder(binder, binder.context);
+
+	// Find argument types and separate positional and default arguments
+	vector<LogicalType> positional_arg_types;
+	InsertionOrderPreservingMap<LogicalType> named_arg_types;
 	for (auto &arg : function_expr.children) {
+		auto arg_copy = arg->Copy();
+		const auto arg_bind_result = expr_binder.BindExpression(arg_copy, depth + 1);
+		auto arg_type = arg_bind_result.HasError() ? LogicalType::UNKNOWN : arg_bind_result.expression->return_type;
 		if (!arg->GetAlias().empty()) {
-			// default argument
-			if (defaults.count(arg->GetAlias())) {
-				return MacroBindResult(StringUtil::Format("Duplicate default parameters %s!", arg->GetAlias()));
+			// Default argument
+			if (named_arguments.find(arg->GetAlias()) != named_arguments.end()) {
+				return MacroBindResult(
+				    StringUtil::Format("Macro %s() has named argument repeated '%s'", name, arg->GetAlias()));
 			}
-			defaults[arg->GetAlias()] = std::move(arg);
-		} else if (!defaults.empty()) {
-			return MacroBindResult("Positional parameters cannot come after parameters with a default value!");
+			named_arg_types.insert(arg->GetAlias(), std::move(arg_type));
+			named_arguments[arg->GetAlias()] = std::move(arg);
+		} else if (!named_arguments.empty()) {
+			return MacroBindResult(
+			    StringUtil::Format("Macro %s() has positional argument following named argument", name));
 		} else {
-			// positional argument
-			positionals.push_back(std::move(arg));
+			// Positional argument
+			positional_arguments.push_back(std::move(arg));
+			positional_arg_types.push_back(std::move(arg_type));
 		}
 	}
 
-	// check for each macro function if it matches the number of positional arguments
-	optional_idx result_idx;
+	// Check for each macro function if it matches the number of positional arguments
+	auto lowest_cost = NumericLimits<idx_t>::Maximum();
+	vector<idx_t> result_indices;
 	for (idx_t function_idx = 0; function_idx < functions.size(); function_idx++) {
-		if (functions[function_idx]->parameters.size() == positionals.size()) {
-			// found a matching function
-			result_idx = function_idx;
-			break;
+		auto &function = functions[function_idx];
+
+		// At some point we want to guarantee that this has the same size as "parameters", but for now we fill to match
+		auto parameter_types = function->types;
+		parameter_types.resize(function->parameters.size(), LogicalType::UNKNOWN);
+
+		// Check if we can exclude the match based on argument count (also avoids out-of-bounds below)
+		if (positional_arguments.size() > function->parameters.size() ||
+		    positional_arguments.size() + named_arguments.size() > function->parameters.size()) {
+			continue;
+		}
+
+		// Also check if we can exclude the match based on the supplied named arguments
+		bool bail = false;
+		for (auto &kv : named_arguments) {
+			bool found = false;
+			for (const auto &parameter : function->parameters) {
+				if (StringUtil::CIEquals(kv.first, parameter->Cast<ColumnRefExpression>().GetColumnName())) {
+					found = true;
+					break;
+				}
+			}
+			if (!found) {
+				bail = true;
+				break;
+			}
+		}
+		if (bail) {
+			continue; // One of the supplied named arguments is not present in the macro definition
+		}
+
+		// Loop through arguments, positionals first, then named, summing up cost for best matching macro as we go
+		idx_t param_idx = 0;
+		idx_t macro_cost = 0;
+
+		// Figure out best function fit, bail if any positional arguments are duplicated in named arguments
+		for (; param_idx < positional_arguments.size(); param_idx++) {
+			const auto &param_name = function->parameters[param_idx]->Cast<ColumnRefExpression>().GetColumnName();
+			if (named_arguments.find(param_name) != named_arguments.end()) {
+				bail = true;
+				break;
+			}
+			const auto &param_type = parameter_types[param_idx];
+			if (param_type == LogicalType::UNKNOWN) {
+				macro_cost += 1000000;
+			} else {
+				const auto cast_cost =
+				    CastFunctionSet::ImplicitCastCost(binder.context, positional_arg_types[param_idx], param_type);
+				if (cast_cost < 0) {
+					bail = true;
+					break;
+				}
+				macro_cost += NumericCast<idx_t>(cast_cost);
+			}
+		}
+		if (bail) {
+			continue; // Couldn't find one of the supplied named arguments, or one of the casts is not possible
+		}
+
+		// Match remaining arguments with named/defaults
+		for (; param_idx < function->parameters.size(); param_idx++) {
+			const auto &param_name = function->parameters[param_idx]->Cast<ColumnRefExpression>().GetColumnName();
+			const auto arg_it = named_arguments.find(param_name);
+			const auto default_it = function->default_parameters.find(param_name);
+			if (arg_it == named_arguments.end() && default_it == function->default_parameters.end()) {
+				break; // The parameter has no argument (supplied/default)!
+			}
+			if (arg_it == named_arguments.end()) {
+				continue; // Using default, no cost
+			}
+
+			// Supplied arg, add cost
+			const auto &param_type = parameter_types[param_idx];
+			if (param_type == LogicalType::UNKNOWN) {
+				macro_cost += 1000000;
+			} else {
+				const auto cast_cost =
+				    CastFunctionSet::ImplicitCastCost(binder.context, named_arg_types[param_name], param_type);
+				if (cast_cost < 0) {
+					break; // No cast possible
+				}
+				macro_cost += NumericCast<idx_t>(cast_cost);
+			}
+		}
+
+		if (param_idx == function->parameters.size() && macro_cost <= lowest_cost) {
+			// Found a matching function
+			if (macro_cost < lowest_cost) {
+				lowest_cost = macro_cost;
+				result_indices.clear();
+			}
+			result_indices.push_back(function_idx);
 		}
 	}
-	if (!result_idx.IsValid()) {
-		// no matching function found
+
+	if (result_indices.size() != 1) {
 		string error;
-		if (functions.size() == 1) {
-			// we only have one function - print the old more detailed error message
-			auto &macro_def = *functions[0];
-			auto &parameters = macro_def.parameters;
-			error = StringUtil::Format("Macro function %s requires ", FormatMacroFunction(macro_def, name));
-			error += parameters.size() == 1 ? "a single positional argument"
-			                                : StringUtil::Format("%i positional arguments", parameters.size());
-			error += ", but ";
-			error += positionals.size() == 1 ? "a single positional argument was"
-			                                 : StringUtil::Format("%i positional arguments were", positionals.size());
-			error += " provided.";
-		} else {
-			// we have multiple functions - list all candidates
-			error += StringUtil::Format("Macro \"%s\" does not support %llu parameters.\n", name, positionals.size());
+		if (result_indices.empty()) {
+			// No matching function found
+			error = StringUtil::Format("Macro %s() does not support the supplied arguments.", name);
+			error += " You might need to add explicit type casts.\n";
 			error += "Candidate macros:";
 			for (auto &function : functions) {
 				error += "\n\t" + FormatMacroFunction(*function, name);
 			}
+		} else {
+			// Multiple matching functions found
+			error = StringUtil::Format("Macro %s() has multiple overloads that match the supplied arguments.\n", name);
+			error += "In order to select one, please supply all arguments by name, and/or add explicit type casts.\n";
+			error += "Candidate macros:";
+			for (const auto &result_idx : result_indices) {
+				error += "\n\t" + FormatMacroFunction(*functions[result_idx], name);
+			}
 		}
+
 		return MacroBindResult(error);
 	}
-	// found a matching index - check if the default values exist within the macro
-	auto macro_idx = result_idx.GetIndex();
-	auto &macro_def = *functions[macro_idx];
-	for (auto &default_val : defaults) {
-		auto entry = macro_def.default_parameters.find(default_val.first);
-		if (entry == macro_def.default_parameters.end()) {
-			string error =
-			    StringUtil::Format("Macro \"%s\" does not have a named parameter \"%s\"\n", name, default_val.first);
-			error += "\nMacro definition: " + FormatMacroFunction(macro_def, name);
-			return MacroBindResult(error);
+
+	const auto &macro_idx = result_indices[0];
+	const auto &macro_def = *functions[macro_idx];
+
+	// Cast positionals to proper types
+	auto parameter_types = macro_def.types;
+	parameter_types.resize(macro_def.parameters.size(), LogicalType::UNKNOWN);
+	idx_t param_idx = 0;
+	for (; param_idx < positional_arguments.size(); param_idx++) {
+		if (parameter_types[param_idx] != LogicalType::UNKNOWN) {
+			// This macro parameter is typed, add a cast
+			auto &positional_arg = positional_arguments[param_idx];
+			positional_arg = make_uniq<CastExpression>(parameter_types[param_idx], std::move(positional_arg));
 		}
 	}
-	// Add the default values for parameters that have defaults, that were not explicitly assigned to
-	for (auto it = macro_def.default_parameters.begin(); it != macro_def.default_parameters.end(); it++) {
-		auto &parameter_name = it->first;
-		auto &parameter_default = it->second;
-		if (!defaults.count(parameter_name)) {
-			// This parameter was not set yet, set it with the default value
-			defaults[parameter_name] = parameter_default->Copy();
+
+	// Add the default values for parameters that have defaults, for which no argument was supplied
+	for (; param_idx < macro_def.parameters.size(); param_idx++) {
+		const auto &param_name = macro_def.parameters[param_idx]->Cast<ColumnRefExpression>().GetColumnName();
+		auto named_arg_it = named_arguments.find(param_name);
+		if (named_arg_it != named_arguments.end()) {
+			// The user has supplied an argument for this parameter
+			if (parameter_types[param_idx] != LogicalType::UNKNOWN) {
+				// This macro parameter is typed, add a cast
+				auto &named_arg = named_arg_it->second;
+				named_arg = make_uniq<CastExpression>(parameter_types[param_idx], std::move(named_arg));
+			}
+			continue;
+		}
+
+		const auto default_it = macro_def.default_parameters.find(param_name);
+		D_ASSERT(default_it != macro_def.default_parameters.end());
+		auto &named_arg = named_arguments[param_name];
+		named_arg = default_it->second->Copy();
+		if (parameter_types[param_idx] != LogicalType::UNKNOWN) {
+			// This macro parameter is typed, add a cast
+			named_arg = make_uniq<CastExpression>(parameter_types[param_idx], std::move(named_arg));
 		}
 	}
+
 	return MacroBindResult(macro_idx);
 }
 
+unique_ptr<DummyBinding>
+MacroFunction::CreateDummyBinding(const MacroFunction &macro_def, const string &name,
+                                  vector<unique_ptr<ParsedExpression>> &positional_arguments,
+                                  InsertionOrderPreservingMap<unique_ptr<ParsedExpression>> &named_arguments) {
+	// create a MacroBinding to bind this macro's parameters to its arguments
+	vector<LogicalType> types = macro_def.types;
+	types.resize(macro_def.parameters.size(), LogicalType::UNKNOWN);
+	vector<string> names;
+	for (idx_t i = 0; i < positional_arguments.size(); i++) {
+		names.push_back(macro_def.parameters[i]->Cast<ColumnRefExpression>().GetColumnName());
+	}
+	for (auto &kv : named_arguments) {
+		names.push_back(kv.first);
+		positional_arguments.push_back(std::move(kv.second)); // push defaults into positionals
+	}
+
+	auto res = make_uniq<DummyBinding>(types, names, name);
+	res->arguments = &positional_arguments;
+	return res;
+}
+
 void MacroFunction::CopyProperties(MacroFunction &other) const {
 	other.type = type;
 	for (auto &param : parameters) {
@@ -122,15 +266,64 @@ void MacroFunction::CopyProperties(MacroFunction &other) const {
 	for (auto &kv : default_parameters) {
 		other.default_parameters[kv.first] = kv.second->Copy();
 	}
+	other.types = types;
 }
 
-string MacroFunction::ToSQL() const {
-	vector<string> param_strings;
+vector<unique_ptr<ParsedExpression>>
+MacroFunction::GetPositionalParametersForSerialization(Serializer &serializer) const {
+	vector<unique_ptr<ParsedExpression>> result;
+	if (serializer.ShouldSerialize(6)) {
+		// We serialize all positional parameters as-is
+		for (auto &param : parameters) {
+			result.push_back(param->Copy());
+		}
+		return result;
+	}
+	// Serializing targeting an older version - delete all named parameters from the list of positional parmaeters
 	for (auto &param : parameters) {
-		param_strings.push_back(param->ToString());
+		auto &colref = param->Cast<ColumnRefExpression>();
+		if (default_parameters.find(colref.GetName()) != default_parameters.end()) {
+			// This is a default parameter - do not serialize
+			continue;
+		}
+		result.push_back(param->Copy());
 	}
-	for (auto &named_param : default_parameters) {
-		param_strings.push_back(StringUtil::Format("%s := %s", named_param.first, named_param.second->ToString()));
+	return result;
+}
+
+void MacroFunction::FinalizeDeserialization() {
+	// In older versions of DuckDB, parameters with defaults were not stored in "parameters", this adds them
+	for (auto &kv : default_parameters) {
+		bool found = false;
+		for (const auto &parameter : parameters) {
+			if (StringUtil::CIEquals(kv.first, parameter->Cast<ColumnRefExpression>().GetColumnName())) {
+				found = true;
+				break;
+			}
+		}
+		if (!found) {
+			parameters.push_back(make_uniq<ColumnRefExpression>(kv.first));
+		}
+	}
+	// In older versions of DuckDB macros were always untyped
+	if (parameters.size() != types.size()) {
+		types.resize(parameters.size(), LogicalType::UNKNOWN);
+	}
+}
+
+string MacroFunction::ToSQL() const {
+	vector<string> param_strings;
+	for (idx_t param_idx = 0; param_idx < parameters.size(); param_idx++) {
+		const auto &param_name = parameters[param_idx]->Cast<ColumnRefExpression>().GetColumnName();
+		auto param_string = param_name;
+		if (types[param_idx] != LogicalType::UNKNOWN) {
+			param_string += " " + types[param_idx].ToString();
+		}
+		auto it = default_parameters.find(param_name);
+		if (it != default_parameters.end()) {
+			param_string += " := " + it->second->ToString();
+		}
+		param_strings.push_back(std::move(param_string));
 	}
 	return StringUtil::Format("(%s) AS ", StringUtil::Join(param_strings, ", "));
 }

package/src/duckdb/src/function/pragma/pragma_functions.cpp

@@ -11,6 +11,8 @@
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/common/encryption_functions.hpp"
+#include "duckdb/logging/log_manager.hpp"
 
 #include <cctype>
 
@@ -93,10 +95,6 @@ static void PragmaForceCheckpoint(ClientContext &context, const FunctionParamete
 	DBConfig::GetConfig(context).options.force_checkpoint = true;
 }
 
-static void PragmaTruncateDuckDBLogs(ClientContext &context, const FunctionParameters &parameters) {
-	context.db->GetLogManager().TruncateLogStorage();
-}
-
 static void PragmaDisableForceParallelism(ClientContext &context, const FunctionParameters &parameters) {
 	ClientConfig::GetConfig(context).verify_parallelism = false;
 }
@@ -115,35 +113,6 @@ static void PragmaDisableCheckpointOnShutdown(ClientContext &context, const Func
 	DBConfig::GetConfig(context).options.checkpoint_on_shutdown = false;
 }
 
-static void PragmaEnableLogging(ClientContext &context, const FunctionParameters &parameters) {
-	if (parameters.values.empty()) {
-		context.db->GetLogManager().SetEnableLogging(true);
-		return;
-	}
-
-	if (parameters.values.size() != 1) {
-		throw InvalidInputException("PragmaEnableLogging: expected 0 or 1 parameter");
-	}
-
-	vector<string> types;
-
-	if (parameters.values[0].type() == LogicalType::VARCHAR) {
-		types.push_back(parameters.values[0].GetValue<string>());
-	} else if (parameters.values[0].type() == LogicalType::LIST(LogicalType::VARCHAR)) {
-		for (const auto &child : ListValue::GetChildren(parameters.values[0])) {
-			types.push_back(child.GetValue<string>());
-		}
-	} else {
-		throw InvalidInputException("Unexpected type for PragmaEnableLogging");
-	}
-
-	context.db->GetLogManager().SetEnableStructuredLoggers(types);
-}
-
-static void PragmaDisableLogging(ClientContext &context, const FunctionParameters &parameters) {
-	context.db->GetLogManager().SetEnableLogging(false);
-}
-
 static void PragmaEnableOptimizer(ClientContext &context, const FunctionParameters &parameters) {
 	ClientConfig::GetConfig(context).enable_optimizer = true;
 }
@@ -155,6 +124,10 @@ static void PragmaDisableOptimizer(ClientContext &context, const FunctionParamet
 void PragmaFunctions::RegisterFunction(BuiltinFunctions &set) {
 	RegisterEnableProfiling(set);
 
+	// NOTE: use of Pragma functions is discouraged. Instead, opt for adding a regular table function to be invoked with
+	// CALL.
+	//       see for example the "enable_logging" function
+
 	set.AddFunction(PragmaFunction::PragmaStatement("disable_profile", PragmaDisableProfiling));
 	set.AddFunction(PragmaFunction::PragmaStatement("disable_profiling", PragmaDisableProfiling));
 
@@ -176,16 +149,11 @@ void PragmaFunctions::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(PragmaFunction::PragmaStatement("enable_object_cache", PragmaEnableObjectCache));
 	set.AddFunction(PragmaFunction::PragmaStatement("disable_object_cache", PragmaDisableObjectCache));
 
-	set.AddFunction(PragmaFunction::PragmaCall("enable_logging", PragmaEnableLogging, {}, LogicalType::VARCHAR));
-	set.AddFunction(PragmaFunction::PragmaStatement("disable_logging", PragmaDisableLogging));
-
 	set.AddFunction(PragmaFunction::PragmaStatement("enable_optimizer", PragmaEnableOptimizer));
 	set.AddFunction(PragmaFunction::PragmaStatement("disable_optimizer", PragmaDisableOptimizer));
 
 	set.AddFunction(PragmaFunction::PragmaStatement("force_checkpoint", PragmaForceCheckpoint));
 
-	set.AddFunction(PragmaFunction::PragmaStatement("truncate_duckdb_logs", PragmaTruncateDuckDBLogs));
-
 	set.AddFunction(PragmaFunction::PragmaStatement("enable_progress_bar", PragmaEnableProgressBar));
 	set.AddFunction(PragmaFunction::PragmaStatement("disable_progress_bar", PragmaDisableProgressBar));
 

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -14,24 +14,37 @@
 
 namespace duckdb {
 
-string PragmaTableInfo(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaTableInfo(ClientContext &context, const FunctionParameters &parameters) {
 	return StringUtil::Format("SELECT * FROM pragma_table_info(%s);",
 	                          KeywordHelper::WriteQuoted(parameters.values[0].ToString(), '\''));
 }
 
-string PragmaShowTables() {
+string PragmaShowTables(const string &database, const string &schema) {
+	string where_clause = "";
+	vector<string> where_conditions;
+	if (!database.empty()) {
+		where_conditions.push_back(StringUtil::Format("lower(database_name) = lower(%s)", SQLString(database)));
+	}
+	if (!schema.empty()) {
+		where_conditions.push_back(StringUtil::Format("lower(schema_name) = lower(%s)", SQLString(schema)));
+	}
+	if (where_conditions.empty()) {
+		where_conditions.push_back("in_search_path(database_name, schema_name)");
+	}
+	where_clause = "WHERE " + StringUtil::Join(where_conditions, " AND ");
+
 	// clang-format off
-	return R"EOF(
+	string query = R"EOF(
 	with "tables" as
 	(
 		SELECT table_name as "name"
 		FROM duckdb_tables
-		where in_search_path(database_name, schema_name)
+		)EOF" + where_clause + R"EOF(
 	), "views" as
 	(
 		SELECT view_name as "name"
 		FROM duckdb_views
-		where in_search_path(database_name, schema_name)
+		)EOF" + where_clause + R"EOF(
 	), db_objects as
 	(
 		SELECT "name" FROM "tables"
@@ -41,10 +54,12 @@ string PragmaShowTables() {
 	SELECT "name"
 	FROM db_objects
 	ORDER BY "name";)EOF";
+
+	return query;
 	// clang-format on
 }
 
-string PragmaShowTables(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaShowTables(ClientContext &context, const FunctionParameters &parameters) {
 	return PragmaShowTables();
 }
 
@@ -80,7 +95,7 @@ string PragmaShowTablesExpanded() {
 	)";
 }
 
-string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters &parameters) {
 	return PragmaShowTablesExpanded();
 }
 
@@ -88,27 +103,27 @@ string PragmaShowDatabases() {
 	return "SELECT database_name FROM duckdb_databases() WHERE NOT internal ORDER BY database_name;";
 }
 
-string PragmaShowDatabases(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaShowDatabases(ClientContext &context, const FunctionParameters &parameters) {
 	return PragmaShowDatabases();
 }
 
 string PragmaShowVariables() {
 	return "SELECT * FROM duckdb_variables() ORDER BY name";
 }
-string PragmaAllProfiling(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaAllProfiling(ClientContext &context, const FunctionParameters &parameters) {
 	return "SELECT * FROM pragma_last_profiling_output() JOIN pragma_detailed_profiling_output() ON "
 	       "(pragma_last_profiling_output.operator_id);";
 }
 
-string PragmaDatabaseList(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaDatabaseList(ClientContext &context, const FunctionParameters &parameters) {
 	return "SELECT * FROM pragma_database_list;";
 }
 
-string PragmaCollations(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaCollations(ClientContext &context, const FunctionParameters &parameters) {
 	return "SELECT * FROM pragma_collations() ORDER BY 1;";
 }
 
-string PragmaFunctionsQuery(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaFunctionsQuery(ClientContext &context, const FunctionParameters &parameters) {
 	return "SELECT function_name AS name, upper(function_type) AS type, parameter_types AS parameters, varargs, "
 	       "return_type, has_side_effects AS side_effects"
 	       " FROM duckdb_functions()"
@@ -120,24 +135,24 @@ string PragmaShow(const string &table_name) {
 	return StringUtil::Format("SELECT * FROM pragma_show(%s);", KeywordHelper::WriteQuoted(table_name, '\''));
 }
 
-string PragmaShow(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaShow(ClientContext &context, const FunctionParameters &parameters) {
 	return PragmaShow(parameters.values[0].ToString());
 }
 
-string PragmaVersion(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaVersion(ClientContext &context, const FunctionParameters &parameters) {
 	return "SELECT * FROM pragma_version();";
 }
 
-string PragmaExtensionVersions(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaExtensionVersions(ClientContext &context, const FunctionParameters &parameters) {
 	return "select extension_name, extension_version, install_mode, installed_from from duckdb_extensions() where "
 	       "installed";
 }
 
-string PragmaPlatform(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaPlatform(ClientContext &context, const FunctionParameters &parameters) {
 	return "SELECT * FROM pragma_platform();";
 }
 
-string PragmaImportDatabase(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaImportDatabase(ClientContext &context, const FunctionParameters &parameters) {
 	auto &fs = FileSystem::GetFileSystem(context);
 
 	string final_query;
@@ -170,7 +185,7 @@ string PragmaImportDatabase(ClientContext &context, const FunctionParameters &pa
 	return final_query;
 }
 
-string PragmaCopyDatabase(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaCopyDatabase(ClientContext &context, const FunctionParameters &parameters) {
 	string copy_stmt = "COPY FROM DATABASE ";
 	copy_stmt += KeywordHelper::WriteOptionallyQuoted(parameters.values[0].ToString());
 	copy_stmt += " TO ";
@@ -181,19 +196,19 @@ string PragmaCopyDatabase(ClientContext &context, const FunctionParameters &para
 	return final_query;
 }
 
-string PragmaDatabaseSize(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaDatabaseSize(ClientContext &context, const FunctionParameters &parameters) {
 	return "SELECT * FROM pragma_database_size();";
 }
 
-string PragmaStorageInfo(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaStorageInfo(ClientContext &context, const FunctionParameters &parameters) {
 	return StringUtil::Format("SELECT * FROM pragma_storage_info('%s');", parameters.values[0].ToString());
 }
 
-string PragmaMetadataInfo(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaMetadataInfo(ClientContext &context, const FunctionParameters &parameters) {
 	return "SELECT * FROM pragma_metadata_info();";
 }
 
-string PragmaUserAgent(ClientContext &context, const FunctionParameters &parameters) {
+static string PragmaUserAgent(ClientContext &context, const FunctionParameters &parameters) {
 	return "SELECT * FROM pragma_user_agent()";
 }
 

package/src/duckdb/src/function/register_function_list.cpp

@@ -4,7 +4,7 @@
 #include "duckdb/function/register_function_list_helper.hpp"
 #include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-#include "duckdb/main/extension_util.hpp"
+#include "duckdb/main/extension/extension_loader.hpp"
 
 namespace duckdb {
 
@@ -34,8 +34,8 @@ struct ExtensionRegister {
 	}
 
 	template <class T>
-	static void RegisterFunction(DatabaseInstance &db, T &info) {
-		ExtensionUtil::RegisterFunction(db, std::move(info));
+	static void RegisterFunction(ExtensionLoader &loader, T &info) {
+		loader.RegisterFunction(std::move(info));
 	}
 };
 
@@ -81,8 +81,8 @@ static void RegisterFunctionList(REGISTER_CONTEXT &context, const StaticFunction
 	}
 }
 
-void FunctionList::RegisterExtensionFunctions(DatabaseInstance &db, const StaticFunctionDefinition *functions) {
-	RegisterFunctionList<ExtensionRegister>(db, functions);
+void FunctionList::RegisterExtensionFunctions(ExtensionLoader &loader, const StaticFunctionDefinition *functions) {
+	RegisterFunctionList<ExtensionRegister>(loader, functions);
 }
 
 void FunctionList::RegisterFunctions(Catalog &catalog, CatalogTransaction transaction) {