duckdb 0.8.2-dev5120.0 → 0.8.2-dev5216.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev5120.0",
+  "version": "0.8.2-dev5216.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/icu/icu-dateadd.cpp

@@ -1,5 +1,6 @@
 #include "include/icu-dateadd.hpp"
 
+#include "duckdb/main/extension_util.hpp"
 #include "duckdb/common/operator/add.hpp"
 #include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/common/types/time.hpp"
@@ -237,17 +238,14 @@ struct ICUDateAdd : public ICUDateFunc {
 		return GetBinaryDateFunction<TA, TB, timestamp_t, OP>(left_type, right_type, LogicalType::TIMESTAMP_TZ);
 	}
 
-	static void AddDateAddOperators(const string &name, ClientContext &context) {
+	static void AddDateAddOperators(const string &name, DatabaseInstance &db) {
 		//	temporal + interval
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetDateAddFunction<timestamp_t, interval_t, ICUCalendarAdd>(LogicalType::TIMESTAMP_TZ,
 		                                                                            LogicalType::INTERVAL));
 		set.AddFunction(GetDateAddFunction<interval_t, timestamp_t, ICUCalendarAdd>(LogicalType::INTERVAL,
 		                                                                            LogicalType::TIMESTAMP_TZ));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 
 	template <typename TA, typename OP>
@@ -260,7 +258,7 @@ struct ICUDateAdd : public ICUDateFunc {
 		return GetBinaryDateFunction<TA, TB, interval_t, OP>(left_type, right_type, LogicalType::INTERVAL);
 	}
 
-	static void AddDateSubOperators(const string &name, ClientContext &context) {
+	static void AddDateSubOperators(const string &name, DatabaseInstance &db) {
 		//	temporal - interval
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetDateAddFunction<timestamp_t, interval_t, ICUCalendarSub>(LogicalType::TIMESTAMP_TZ,
@@ -269,22 +267,16 @@ struct ICUDateAdd : public ICUDateFunc {
 		//	temporal - temporal
 		set.AddFunction(GetBinaryAgeFunction<timestamp_t, timestamp_t, ICUCalendarSub>(LogicalType::TIMESTAMP_TZ,
 		                                                                               LogicalType::TIMESTAMP_TZ));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 
-	static void AddDateAgeFunctions(const string &name, ClientContext &context) {
+	static void AddDateAgeFunctions(const string &name, DatabaseInstance &db) {
 		//	age(temporal, temporal)
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetBinaryAgeFunction<timestamp_t, timestamp_t, ICUCalendarAge>(LogicalType::TIMESTAMP_TZ,
 		                                                                               LogicalType::TIMESTAMP_TZ));
 		set.AddFunction(GetUnaryAgeFunction<timestamp_t, ICUCalendarAge>(LogicalType::TIMESTAMP_TZ));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 };
 
@@ -300,10 +292,10 @@ interval_t ICUDateFunc::Sub(icu::Calendar *calendar, timestamp_t end_date, times
 	return ICUCalendarSub::Operation<timestamp_t, timestamp_t, interval_t>(end_date, start_date, calendar);
 }
 
-void RegisterICUDateAddFunctions(ClientContext &context) {
-	ICUDateAdd::AddDateAddOperators("+", context);
-	ICUDateAdd::AddDateSubOperators("-", context);
-	ICUDateAdd::AddDateAgeFunctions("age", context);
+void RegisterICUDateAddFunctions(DatabaseInstance &db) {
+	ICUDateAdd::AddDateAddOperators("+", db);
+	ICUDateAdd::AddDateSubOperators("-", db);
+	ICUDateAdd::AddDateAgeFunctions("age", db);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu-datepart.cpp

@@ -1,6 +1,7 @@
 #include "include/icu-datepart.hpp"
 #include "include/icu-datefunc.hpp"
 
+#include "duckdb/main/extension_util.hpp"
 #include "duckdb/common/enums/date_part_specifier.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/timestamp.hpp"
@@ -562,13 +563,11 @@ struct ICUDatePart : public ICUDateFunc {
 	}
 
 	template <typename RESULT_TYPE = int64_t>
-	static void AddUnaryPartCodeFunctions(const string &name, ClientContext &context,
+	static void AddUnaryPartCodeFunctions(const string &name, DatabaseInstance &db,
 	                                      const LogicalType &result_type = LogicalType::BIGINT) {
-		auto &catalog = Catalog::GetSystemCatalog(context);
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetUnaryPartCodeFunction<timestamp_t, RESULT_TYPE>(LogicalType::TIMESTAMP_TZ, result_type));
-		CreateScalarFunctionInfo func_info(set);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 
 	template <typename INPUT_TYPE, typename RESULT_TYPE>
@@ -587,13 +586,11 @@ struct ICUDatePart : public ICUDateFunc {
 		return result;
 	}
 
-	static void AddDatePartFunctions(const string &name, ClientContext &context) {
-		auto &catalog = Catalog::GetSystemCatalog(context);
+	static void AddDatePartFunctions(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetBinaryPartCodeFunction<timestamp_t, int64_t>(LogicalType::TIMESTAMP_TZ));
 		set.AddFunction(GetStructFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-		CreateScalarFunctionInfo func_info(set);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 
 	static duckdb::unique_ptr<FunctionData> BindLastDate(ClientContext &context, ScalarFunction &bound_function,
@@ -607,12 +604,10 @@ struct ICUDatePart : public ICUDateFunc {
 		return ScalarFunction({temporal_type}, LogicalType::DATE, UnaryTimestampFunction<INPUT_TYPE, date_t>,
 		                      BindLastDate);
 	}
-	static void AddLastDayFunctions(const string &name, ClientContext &context) {
-		auto &catalog = Catalog::GetSystemCatalog(context);
+	static void AddLastDayFunctions(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetLastDayFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-		CreateScalarFunctionInfo func_info(set);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 
 	static unique_ptr<FunctionData> BindMonthName(ClientContext &context, ScalarFunction &bound_function,
@@ -626,12 +621,10 @@ struct ICUDatePart : public ICUDateFunc {
 		return ScalarFunction({temporal_type}, LogicalType::VARCHAR, UnaryTimestampFunction<INPUT_TYPE, string_t>,
 		                      BindMonthName);
 	}
-	static void AddMonthNameFunctions(const string &name, ClientContext &context) {
-		auto &catalog = Catalog::GetSystemCatalog(context);
+	static void AddMonthNameFunctions(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetMonthNameFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-		CreateScalarFunctionInfo func_info(set);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 
 	static unique_ptr<FunctionData> BindDayName(ClientContext &context, ScalarFunction &bound_function,
@@ -645,63 +638,61 @@ struct ICUDatePart : public ICUDateFunc {
 		return ScalarFunction({temporal_type}, LogicalType::VARCHAR, UnaryTimestampFunction<INPUT_TYPE, string_t>,
 		                      BindDayName);
 	}
-	static void AddDayNameFunctions(const string &name, ClientContext &context) {
-		auto &catalog = Catalog::GetSystemCatalog(context);
+	static void AddDayNameFunctions(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetDayNameFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-		CreateScalarFunctionInfo func_info(set);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 };
 
-void RegisterICUDatePartFunctions(ClientContext &context) {
+void RegisterICUDatePartFunctions(DatabaseInstance &db) {
 	// register the individual operators
 
 	//	BIGINTs
-	ICUDatePart::AddUnaryPartCodeFunctions("era", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("year", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("month", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("day", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("decade", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("century", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("millennium", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("microsecond", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("millisecond", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("second", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("minute", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("hour", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("dayofweek", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("isodow", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("week", context); //  Note that WeekOperator is ISO-8601, not US
-	ICUDatePart::AddUnaryPartCodeFunctions("dayofyear", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("quarter", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("isoyear", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("timezone", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("timezone_hour", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("timezone_minute", context);
+	ICUDatePart::AddUnaryPartCodeFunctions("era", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("year", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("month", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("day", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("decade", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("century", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("millennium", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("microsecond", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("millisecond", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("second", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("minute", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("hour", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("dayofweek", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("isodow", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("week", db); //  Note that WeekOperator is ISO-8601, not US
+	ICUDatePart::AddUnaryPartCodeFunctions("dayofyear", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("quarter", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("isoyear", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("timezone", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("timezone_hour", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("timezone_minute", db);
 
 	//	DOUBLEs
-	ICUDatePart::AddUnaryPartCodeFunctions<double>("epoch", context, LogicalType::DOUBLE);
-	ICUDatePart::AddUnaryPartCodeFunctions<double>("julian", context, LogicalType::DOUBLE);
+	ICUDatePart::AddUnaryPartCodeFunctions<double>("epoch", db, LogicalType::DOUBLE);
+	ICUDatePart::AddUnaryPartCodeFunctions<double>("julian", db, LogicalType::DOUBLE);
 
 	//  register combinations
-	ICUDatePart::AddUnaryPartCodeFunctions("yearweek", context); //  Note this is ISO year and week
+	ICUDatePart::AddUnaryPartCodeFunctions("yearweek", db); //  Note this is ISO year and week
 
 	//  register various aliases
-	ICUDatePart::AddUnaryPartCodeFunctions("dayofmonth", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("weekday", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("weekofyear", context);
+	ICUDatePart::AddUnaryPartCodeFunctions("dayofmonth", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("weekday", db);
+	ICUDatePart::AddUnaryPartCodeFunctions("weekofyear", db);
 
 	//  register the last_day function
-	ICUDatePart::AddLastDayFunctions("last_day", context);
+	ICUDatePart::AddLastDayFunctions("last_day", db);
 
 	// register the dayname/monthname functions
-	ICUDatePart::AddMonthNameFunctions("monthname", context);
-	ICUDatePart::AddDayNameFunctions("dayname", context);
+	ICUDatePart::AddMonthNameFunctions("monthname", db);
+	ICUDatePart::AddDayNameFunctions("dayname", db);
 
 	// finally the actual date_part function
-	ICUDatePart::AddDatePartFunctions("date_part", context);
-	ICUDatePart::AddDatePartFunctions("datepart", context);
+	ICUDatePart::AddDatePartFunctions("date_part", db);
+	ICUDatePart::AddDatePartFunctions("datepart", db);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu-datesub.cpp

@@ -1,6 +1,7 @@
 #include "include/icu-datesub.hpp"
 #include "include/icu-datefunc.hpp"
 
+#include "duckdb/main/extension_util.hpp"
 #include "duckdb/common/enums/date_part_specifier.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
@@ -138,13 +139,10 @@ struct ICUCalendarSub : public ICUDateFunc {
 		return ScalarFunction({LogicalType::VARCHAR, type, type}, LogicalType::BIGINT, ICUDateSubFunction<TA>, Bind);
 	}
 
-	static void AddFunctions(const string &name, ClientContext &context) {
+	static void AddFunctions(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 };
 
@@ -266,22 +264,19 @@ struct ICUCalendarDiff : public ICUDateFunc {
 		return ScalarFunction({LogicalType::VARCHAR, type, type}, LogicalType::BIGINT, ICUDateDiffFunction<TA>, Bind);
 	}
 
-	static void AddFunctions(const string &name, ClientContext &context) {
+	static void AddFunctions(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 };
 
-void RegisterICUDateSubFunctions(ClientContext &context) {
-	ICUCalendarSub::AddFunctions("date_sub", context);
-	ICUCalendarSub::AddFunctions("datesub", context);
+void RegisterICUDateSubFunctions(DatabaseInstance &db) {
+	ICUCalendarSub::AddFunctions("date_sub", db);
+	ICUCalendarSub::AddFunctions("datesub", db);
 
-	ICUCalendarDiff::AddFunctions("date_diff", context);
-	ICUCalendarDiff::AddFunctions("datediff", context);
+	ICUCalendarDiff::AddFunctions("date_diff", db);
+	ICUCalendarDiff::AddFunctions("datediff", db);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu-datetrunc.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/main/extension_util.hpp"
 
 namespace duckdb {
 
@@ -140,13 +141,10 @@ struct ICUDateTrunc : public ICUDateFunc {
 		return ScalarFunction({LogicalType::VARCHAR, type}, LogicalType::TIMESTAMP_TZ, ICUDateTruncFunction<TA>, Bind);
 	}
 
-	static void AddBinaryTimestampFunction(const string &name, ClientContext &context) {
+	static void AddBinaryTimestampFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetDateTruncFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 };
 
@@ -193,9 +191,9 @@ ICUDateFunc::part_trunc_t ICUDateFunc::TruncationFactory(DatePartSpecifier type)
 	}
 }
 
-void RegisterICUDateTruncFunctions(ClientContext &context) {
-	ICUDateTrunc::AddBinaryTimestampFunction("date_trunc", context);
-	ICUDateTrunc::AddBinaryTimestampFunction("datetrunc", context);
+void RegisterICUDateTruncFunctions(DatabaseInstance &db) {
+	ICUDateTrunc::AddBinaryTimestampFunction("date_trunc", db);
+	ICUDateTrunc::AddBinaryTimestampFunction("datetrunc", db);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu-list-range.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "include/icu-datefunc.hpp"
+#include "duckdb/main/extension_util.hpp"
 
 namespace duckdb {
 
@@ -180,28 +181,25 @@ struct ICUListRange : public ICUDateFunc {
 		result.Verify(args.size());
 	}
 
-	static void AddICUListRangeFunction(ClientContext &context) {
-		auto &catalog = Catalog::GetSystemCatalog(context);
+	static void AddICUListRangeFunction(DatabaseInstance &db) {
 
 		ScalarFunctionSet range("range");
 		range.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
 		                                 LogicalType::LIST(LogicalType::TIMESTAMP_TZ), ICUListRangeFunction<false>,
 		                                 Bind));
-		CreateScalarFunctionInfo range_func_info(range);
-		catalog.AddFunction(context, range_func_info);
+		ExtensionUtil::AddFunctionOverload(db, range);
 
 		// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
 		ScalarFunctionSet generate_series("generate_series");
 		generate_series.AddFunction(
 		    ScalarFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
 		                   LogicalType::LIST(LogicalType::TIMESTAMP_TZ), ICUListRangeFunction<true>, Bind));
-		CreateScalarFunctionInfo generate_series_func_info(generate_series);
-		catalog.AddFunction(context, generate_series_func_info);
+		ExtensionUtil::AddFunctionOverload(db, generate_series);
 	}
 };
 
-void RegisterICUListRangeFunctions(ClientContext &context) {
-	ICUListRange::AddICUListRangeFunction(context);
+void RegisterICUListRangeFunctions(DatabaseInstance &db) {
+	ICUListRange::AddICUListRangeFunction(db);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu-makedate.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/common/vector_operations/senary_executor.hpp"
 #include "duckdb/common/vector_operations/septenary_executor.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/main/extension_util.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "include/icu-datefunc.hpp"
 #include "include/icu-datetrunc.hpp"
@@ -57,8 +58,8 @@ struct ICUMakeDate : public ICUDateFunc {
 		return BoundCastInfo(CastToDate, std::move(cast_data));
 	}
 
-	static void AddCasts(ClientContext &context) {
-		auto &config = DBConfig::GetConfig(context);
+	static void AddCasts(DatabaseInstance &db) {
+		auto &config = DBConfig::GetConfig(db);
 		auto &casts = config.GetCastFunctions();
 
 		casts.RegisterCastFunction(LogicalType::TIMESTAMP_TZ, LogicalType::DATE, BindCastToDate);
@@ -146,21 +147,18 @@ struct ICUMakeTimestampTZFunc : public ICUDateFunc {
 		                      LogicalType::TIMESTAMP_TZ, Execute<TA>, Bind);
 	}
 
-	static void AddFunction(const string &name, ClientContext &context) {
+	static void AddFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(GetSenaryFunction<int64_t>(LogicalType::BIGINT));
 		set.AddFunction(GetSeptenaryFunction<int64_t>(LogicalType::BIGINT));
 		set.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP_TZ, FromMicros<int64_t>));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };
 
-void RegisterICUMakeDateFunctions(ClientContext &context) {
-	ICUMakeTimestampTZFunc::AddFunction("make_timestamptz", context);
-	ICUMakeDate::AddCasts(context);
+void RegisterICUMakeDateFunctions(DatabaseInstance &db) {
+	ICUMakeTimestampTZFunc::AddFunction("make_timestamptz", db);
+	ICUMakeDate::AddCasts(db);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu-strptime.cpp

@@ -15,6 +15,7 @@
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/function/cast/default_casts.hpp"
+#include "duckdb/main/extension_util.hpp"
 
 namespace duckdb {
 
@@ -211,32 +212,32 @@ struct ICUStrptime : public ICUDateFunc {
 		return bind_strptime(context, bound_function, arguments);
 	}
 
-	static void TailPatch(const string &name, ClientContext &context, const vector<LogicalType> &types) {
+	static void TailPatch(const string &name, DatabaseInstance &db, const vector<LogicalType> &types) {
 		// Find the old function
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		auto &entry = catalog.GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, DEFAULT_SCHEMA, name);
-		D_ASSERT(entry.type == CatalogType::SCALAR_FUNCTION_ENTRY);
-		auto &func = entry.Cast<ScalarFunctionCatalogEntry>();
-		string error;
-
-		FunctionBinder function_binder(context);
-		const idx_t best_function = function_binder.BindFunction(func.name, func.functions, types, error);
-		if (best_function == DConstants::INVALID_INDEX) {
-			return;
+		auto &scalar_function = ExtensionUtil::GetFunction(db, name);
+		auto &functions = scalar_function.functions.functions;
+		optional_idx best_index;
+		for (idx_t i = 0; i < functions.size(); i++) {
+			auto &function = functions[i];
+			if (types == function.arguments) {
+				best_index = i;
+				break;
+			}
 		}
-
-		// Tail patch the old binder
-		auto &bound_function = func.functions.GetFunctionReferenceByOffset(best_function);
+		if (!best_index.IsValid()) {
+			throw InternalException("ICU - Function for TailPatch not found");
+		}
+		auto &bound_function = functions[best_index.GetIndex()];
 		bind_strptime = bound_function.bind;
 		bound_function.bind = StrpTimeBindFunction;
 	}
 
-	static void AddBinaryTimestampFunction(const string &name, ClientContext &context) {
+	static void AddBinaryTimestampFunction(const string &name, DatabaseInstance &db) {
 		vector<LogicalType> types {LogicalType::VARCHAR, LogicalType::VARCHAR};
-		TailPatch(name, context, types);
+		TailPatch(name, db, types);
 
 		types[1] = LogicalType::LIST(LogicalType::VARCHAR);
-		TailPatch(name, context, types);
+		TailPatch(name, db, types);
 	}
 
 	static bool CastFromVarchar(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
@@ -284,8 +285,8 @@ struct ICUStrptime : public ICUDateFunc {
 		return BoundCastInfo(CastFromVarchar, std::move(cast_data));
 	}
 
-	static void AddCasts(ClientContext &context) {
-		auto &config = DBConfig::GetConfig(context);
+	static void AddCasts(DatabaseInstance &db) {
+		auto &config = DBConfig::GetConfig(db);
 		auto &casts = config.GetCastFunctions();
 
 		casts.RegisterCastFunction(LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ, BindCastFromVarchar);
@@ -383,14 +384,11 @@ struct ICUStrftime : public ICUDateFunc {
 		}
 	}
 
-	static void AddBinaryTimestampFunction(const string &name, ClientContext &context) {
+	static void AddBinaryTimestampFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_TZ, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 		                               ICUStrftimeFunction, Bind));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 
 	static string_t CastOperation(icu::Calendar *calendar, timestamp_t input, Vector &result) {
@@ -469,23 +467,23 @@ struct ICUStrftime : public ICUDateFunc {
 		return BoundCastInfo(CastToVarchar, std::move(cast_data));
 	}
 
-	static void AddCasts(ClientContext &context) {
-		auto &config = DBConfig::GetConfig(context);
+	static void AddCasts(DatabaseInstance &db) {
+		auto &config = DBConfig::GetConfig(db);
 		auto &casts = config.GetCastFunctions();
 
 		casts.RegisterCastFunction(LogicalType::TIMESTAMP_TZ, LogicalType::VARCHAR, BindCastToVarchar);
 	}
 };
 
-void RegisterICUStrptimeFunctions(ClientContext &context) {
-	ICUStrptime::AddBinaryTimestampFunction("strptime", context);
-	ICUStrptime::AddBinaryTimestampFunction("try_strptime", context);
+void RegisterICUStrptimeFunctions(DatabaseInstance &db) {
+	ICUStrptime::AddBinaryTimestampFunction("strptime", db);
+	ICUStrptime::AddBinaryTimestampFunction("try_strptime", db);
 
-	ICUStrftime::AddBinaryTimestampFunction("strftime", context);
+	ICUStrftime::AddBinaryTimestampFunction("strftime", db);
 
 	// Add string casts
-	ICUStrptime::AddCasts(context);
-	ICUStrftime::AddCasts(context);
+	ICUStrptime::AddCasts(db);
+	ICUStrftime::AddCasts(db);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu-table-range.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/main/extension_util.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/function/table_function.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
@@ -168,27 +169,23 @@ struct ICUTableRange {
 		output.SetCardinality(size);
 	}
 
-	static void AddICUTableRangeFunction(ClientContext &context) {
-		auto &catalog = Catalog::GetSystemCatalog(context);
-
+	static void AddICUTableRangeFunction(DatabaseInstance &db) {
 		TableFunctionSet range("range");
 		range.AddFunction(TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
 		                                ICUTableRangeFunction, Bind<false>, Init));
-		CreateTableFunctionInfo range_func_info(range);
-		catalog.AddFunction(context, range_func_info);
+		ExtensionUtil::AddFunctionOverload(db, range);
 
 		// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
 		TableFunctionSet generate_series("generate_series");
 		generate_series.AddFunction(
 		    TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
 		                  ICUTableRangeFunction, Bind<true>, Init));
-		CreateTableFunctionInfo generate_series_func_info(generate_series);
-		catalog.AddFunction(context, generate_series_func_info);
+		ExtensionUtil::AddFunctionOverload(db, generate_series);
 	}
 };
 
-void RegisterICUTableRangeFunctions(ClientContext &context) {
-	ICUTableRange::AddICUTableRangeFunction(context);
+void RegisterICUTableRangeFunctions(DatabaseInstance &db) {
+	ICUTableRange::AddICUTableRangeFunction(db);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu-timebucket.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/types/value.hpp"
+#include "duckdb/main/extension_util.hpp"
 #include "duckdb/common/vector_operations/binary_executor.hpp"
 #include "duckdb/common/vector_operations/ternary_executor.hpp"
 #include "duckdb/main/client_context.hpp"
@@ -613,7 +614,7 @@ struct ICUTimeBucket : public ICUDateFunc {
 		}
 	}
 
-	static void AddTimeBucketFunction(ClientContext &context) {
+	static void AddTimeBucketFunction(DatabaseInstance &db) {
 		ScalarFunctionSet set("time_bucket");
 		set.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::TIMESTAMP_TZ}, LogicalType::TIMESTAMP_TZ,
 		                               ICUTimeBucketFunction, Bind));
@@ -623,15 +624,12 @@ struct ICUTimeBucket : public ICUDateFunc {
 		                               LogicalType::TIMESTAMP_TZ, ICUTimeBucketOriginFunction, Bind));
 		set.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::TIMESTAMP_TZ, LogicalType::VARCHAR},
 		                               LogicalType::TIMESTAMP_TZ, ICUTimeBucketTimeZoneFunction, Bind));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 };
 
-void RegisterICUTimeBucketFunctions(ClientContext &context) {
-	ICUTimeBucket::AddTimeBucketFunction(context);
+void RegisterICUTimeBucketFunctions(DatabaseInstance &db) {
+	ICUTimeBucket::AddTimeBucketFunction(db);
 }
 
 } // namespace duckdb