duckdb 0.8.2-dev5120.0 → 0.8.2-dev5154.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-dev5154.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

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

@@ -2,6 +2,7 @@
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.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 "duckdb/parser/parsed_data/create_table_function_info.hpp"
 #include "include/icu-datefunc.hpp"
@@ -143,8 +144,8 @@ struct ICUFromNaiveTimestamp : public ICUDateFunc {
 		return BoundCastInfo(CastFromNaive, 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, LogicalType::TIMESTAMP_TZ, BindCastFromNaive);
@@ -206,8 +207,8 @@ struct ICUToNaiveTimestamp : public ICUDateFunc {
 		return BoundCastInfo(CastToNaive, 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::TIMESTAMP, BindCastToNaive);
@@ -262,18 +263,14 @@ struct ICULocalTimestampFunc : public ICUDateFunc {
 		rdata[0] = GetLocalTimestamp(state);
 	}
 
-	static void AddFunction(const string &name, ClientContext &context) {
+	static void AddFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(ScalarFunction({}, LogicalType::TIMESTAMP, Execute, BindNow));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };
 
 struct ICULocalTimeFunc : public ICUDateFunc {
-
 	static void Execute(DataChunk &input, ExpressionState &state, Vector &result) {
 		D_ASSERT(input.ColumnCount() == 0);
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -282,13 +279,10 @@ struct ICULocalTimeFunc : public ICUDateFunc {
 		rdata[0] = Timestamp::GetTime(local);
 	}
 
-	static void AddFunction(const string &name, ClientContext &context) {
+	static void AddFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(ScalarFunction({}, LogicalType::TIME, Execute, ICULocalTimestampFunc::BindNow));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };
 
@@ -326,16 +320,13 @@ struct ICUTimeZoneFunc : public ICUDateFunc {
 		}
 	}
 
-	static void AddFunction(const string &name, ClientContext &context) {
+	static void AddFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP_TZ,
 		                               Execute<ICUFromNaiveTimestamp>, Bind));
 		set.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ}, LogicalType::TIMESTAMP,
 		                               Execute<ICUToNaiveTimestamp>, Bind));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 };
 
@@ -343,21 +334,19 @@ timestamp_t ICUDateFunc::FromNaive(icu::Calendar *calendar, timestamp_t naive) {
 	return ICUFromNaiveTimestamp::Operation(calendar, naive);
 }
 
-void RegisterICUTimeZoneFunctions(ClientContext &context) {
+void RegisterICUTimeZoneFunctions(DatabaseInstance &db) {
 	//	Table functions
-	auto &catalog = Catalog::GetSystemCatalog(context);
 	TableFunction tz_names("pg_timezone_names", {}, ICUTimeZoneFunction, ICUTimeZoneBind, ICUTimeZoneInit);
-	CreateTableFunctionInfo tz_names_info(std::move(tz_names));
-	catalog.CreateTableFunction(context, tz_names_info);
+	ExtensionUtil::RegisterFunction(db, tz_names);
 
 	//	Scalar functions
-	ICUTimeZoneFunc::AddFunction("timezone", context);
-	ICULocalTimestampFunc::AddFunction("current_localtimestamp", context);
-	ICULocalTimeFunc::AddFunction("current_localtime", context);
+	ICUTimeZoneFunc::AddFunction("timezone", db);
+	ICULocalTimestampFunc::AddFunction("current_localtimestamp", db);
+	ICULocalTimeFunc::AddFunction("current_localtime", db);
 
 	// 	Casts
-	ICUFromNaiveTimestamp::AddCasts(context);
-	ICUToNaiveTimestamp::AddCasts(context);
+	ICUFromNaiveTimestamp::AddCasts(db);
+	ICUToNaiveTimestamp::AddCasts(db);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu_extension.cpp

@@ -8,6 +8,7 @@
 #include "duckdb/main/config.hpp"
 #include "duckdb/main/connection.hpp"
 #include "duckdb/main/database.hpp"
+#include "duckdb/main/extension_util.hpp"
 #include "duckdb/parser/parsed_data/create_collation_info.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
@@ -220,11 +221,9 @@ static void SetICUCalendar(ClientContext &context, SetScope scope, Value &parame
 	}
 }
 
-void IcuExtension::Load(DuckDB &db) {
-	Connection con(db);
-	con.BeginTransaction();
-
-	auto &catalog = Catalog::GetSystemCatalog(*con.context);
+void IcuExtension::Load(DuckDB &ddb) {
+	auto &db = *ddb.instance;
+	auto &catalog = Catalog::GetSystemCatalog(db);
 
 	// iterate over all the collations
 	int32_t count;
@@ -241,17 +240,14 @@ void IcuExtension::Load(DuckDB &db) {
 		collation = StringUtil::Lower(collation);
 
 		CreateCollationInfo info(collation, GetICUFunction(collation), false, true);
-		info.on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-		catalog.CreateCollation(*con.context, info);
+		ExtensionUtil::RegisterCollation(db, info);
 	}
 	ScalarFunction sort_key("icu_sort_key", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                        ICUCollateFunction, ICUSortKeyBind);
-
-	CreateScalarFunctionInfo sort_key_info(std::move(sort_key));
-	catalog.CreateFunction(*con.context, sort_key_info);
+	ExtensionUtil::RegisterFunction(db, sort_key);
 
 	// Time Zones
-	auto &config = DBConfig::GetConfig(*db.instance);
+	auto &config = DBConfig::GetConfig(db);
 	duckdb::unique_ptr<icu::TimeZone> tz(icu::TimeZone::createDefault());
 	icu::UnicodeString tz_id;
 	std::string tz_string;
@@ -259,16 +255,16 @@ void IcuExtension::Load(DuckDB &db) {
 	config.AddExtensionOption("TimeZone", "The current time zone", LogicalType::VARCHAR, Value(tz_string),
 	                          SetICUTimeZone);
 
-	RegisterICUDateAddFunctions(*con.context);
-	RegisterICUDatePartFunctions(*con.context);
-	RegisterICUDateSubFunctions(*con.context);
-	RegisterICUDateTruncFunctions(*con.context);
-	RegisterICUMakeDateFunctions(*con.context);
-	RegisterICUTableRangeFunctions(*con.context);
-	RegisterICUListRangeFunctions(*con.context);
-	RegisterICUStrptimeFunctions(*con.context);
-	RegisterICUTimeBucketFunctions(*con.context);
-	RegisterICUTimeZoneFunctions(*con.context);
+	RegisterICUDateAddFunctions(db);
+	RegisterICUDatePartFunctions(db);
+	RegisterICUDateSubFunctions(db);
+	RegisterICUDateTruncFunctions(db);
+	RegisterICUMakeDateFunctions(db);
+	RegisterICUTableRangeFunctions(db);
+	RegisterICUListRangeFunctions(db);
+	RegisterICUStrptimeFunctions(db);
+	RegisterICUTimeBucketFunctions(db);
+	RegisterICUTimeZoneFunctions(db);
 
 	// Calendars
 	UErrorCode status = U_ZERO_ERROR;
@@ -277,10 +273,7 @@ void IcuExtension::Load(DuckDB &db) {
 	                          SetICUCalendar);
 
 	TableFunction cal_names("icu_calendar_names", {}, ICUCalendarFunction, ICUCalendarBind, ICUCalendarInit);
-	CreateTableFunctionInfo cal_names_info(std::move(cal_names));
-	catalog.CreateTableFunction(*con.context, cal_names_info);
-
-	con.Commit();
+	ExtensionUtil::RegisterFunction(db, cal_names);
 }
 
 std::string IcuExtension::Name() {

package/src/duckdb/extension/icu/include/icu-dateadd.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUDateAddFunctions(ClientContext &context);
+void RegisterICUDateAddFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-datepart.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUDatePartFunctions(ClientContext &context);
+void RegisterICUDatePartFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-datesub.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUDateSubFunctions(ClientContext &context);
+void RegisterICUDateSubFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-datetrunc.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUDateTruncFunctions(ClientContext &context);
+void RegisterICUDateTruncFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-list-range.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUListRangeFunctions(ClientContext &context);
+void RegisterICUListRangeFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-makedate.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUMakeDateFunctions(ClientContext &context);
+void RegisterICUMakeDateFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-strptime.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUStrptimeFunctions(ClientContext &context);
+void RegisterICUStrptimeFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-table-range.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUTableRangeFunctions(ClientContext &context);
+void RegisterICUTableRangeFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-timebucket.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUTimeBucketFunctions(ClientContext &context);
+void RegisterICUTimeBucketFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-timezone.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUTimeZoneFunctions(ClientContext &context);
+void RegisterICUTimeZoneFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/json/json_functions/read_json.cpp

@@ -229,6 +229,21 @@ unique_ptr<FunctionData> ReadJSONBind(ClientContext &context, TableFunctionBindI
 	transform_options.error_unknown_key = bind_data->auto_detect && !bind_data->ignore_errors;
 	transform_options.delay_error = true;
 
+	if (bind_data->auto_detect) {
+		// JSON may contain columns such as "id" and "Id", which are duplicates for us due to case-insensitivity
+		// We rename them so we can parse the file anyway. Note that we can't change bind_data->names,
+		// because the JSON reader gets columns by exact name, not position
+		case_insensitive_map_t<idx_t> name_count_map;
+		for (auto &name : names) {
+			auto it = name_count_map.find(name);
+			if (it == name_count_map.end()) {
+				name_count_map[name] = 1;
+			} else {
+				name = StringUtil::Format("%s_%llu", name, it->second++);
+			}
+		}
+	}
+
 	return std::move(bind_data);
 }
 

package/src/duckdb/src/catalog/catalog.cpp

@@ -479,6 +479,8 @@ bool Catalog::AutoLoadExtensionByCatalogEntry(ClientContext &context, CatalogTyp
 			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS);
 		} else if (type == CatalogType::TYPE_ENTRY) {
 			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES);
+		} else if (type == CatalogType::COLLATION_ENTRY) {
+			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COLLATIONS);
 		}
 
 		if (!extension_name.empty() && ExtensionHelper::CanAutoloadExtension(extension_name)) {
@@ -536,6 +538,8 @@ CatalogException Catalog::CreateMissingEntryException(ClientContext &context, co
 		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES);
 	} else if (type == CatalogType::COPY_FUNCTION_ENTRY) {
 		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS);
+	} else if (type == CatalogType::COLLATION_ENTRY) {
+		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COLLATIONS);
 	}
 
 	// if we found an extension that can handle this catalog entry, create an error hinting the user

package/src/duckdb/src/execution/operator/schema/physical_attach.cpp

@@ -56,7 +56,10 @@ SourceResultType PhysicalAttach::GetData(ExecutionContext &context, DataChunk &c
 
 	// if we are loading a database type from an extension - check if that extension is loaded
 	if (!type.empty()) {
-		if (!db.ExtensionIsLoaded(type)) {
+		if (!Catalog::TryAutoLoad(context.client, type)) {
+			// FIXME: Here it might be preferrable to use an AutoLoadOrThrow kind of function
+			// so that either there will be success or a message to throw, and load will be
+			// attempted only once respecting the autoloading options
 			ExtensionHelper::LoadExternalExtension(context.client, type);
 		}
 	}

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev5120"
+#define DUCKDB_VERSION "0.8.2-dev5154"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "fc2e4b26a6"
+#define DUCKDB_SOURCE_ID "78bea4f92a"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -218,6 +218,32 @@ static constexpr ExtensionEntry EXTENSION_COPY_FUNCTIONS[] = {{"parquet", "parqu
 static constexpr ExtensionEntry EXTENSION_TYPES[] = {
     {"json", "json"}, {"inet", "inet"}, {"geometry", "spatial"}}; // END_OF_EXTENSION_TYPES
 
+// Note: these are currently hardcoded in scripts/generate_extensions_function.py
+// TODO: automate by passing though to script via duckdb
+static constexpr ExtensionEntry EXTENSION_COLLATIONS[] = {
+    {"af", "icu"},    {"am", "icu"},    {"ar", "icu"},     {"ar_sa", "icu"}, {"as", "icu"},    {"az", "icu"},
+    {"be", "icu"},    {"bg", "icu"},    {"bn", "icu"},     {"bo", "icu"},    {"br", "icu"},    {"bs", "icu"},
+    {"ca", "icu"},    {"ceb", "icu"},   {"chr", "icu"},    {"cs", "icu"},    {"cy", "icu"},    {"da", "icu"},
+    {"de", "icu"},    {"de_at", "icu"}, {"dsb", "icu"},    {"dz", "icu"},    {"ee", "icu"},    {"el", "icu"},
+    {"en", "icu"},    {"en_us", "icu"}, {"eo", "icu"},     {"es", "icu"},    {"et", "icu"},    {"fa", "icu"},
+    {"fa_af", "icu"}, {"ff", "icu"},    {"fi", "icu"},     {"fil", "icu"},   {"fo", "icu"},    {"fr", "icu"},
+    {"fr_ca", "icu"}, {"fy", "icu"},    {"ga", "icu"},     {"gl", "icu"},    {"gu", "icu"},    {"ha", "icu"},
+    {"haw", "icu"},   {"he", "icu"},    {"he_il", "icu"},  {"hi", "icu"},    {"hr", "icu"},    {"hsb", "icu"},
+    {"hu", "icu"},    {"hy", "icu"},    {"id", "icu"},     {"id_id", "icu"}, {"ig", "icu"},    {"is", "icu"},
+    {"it", "icu"},    {"ja", "icu"},    {"ka", "icu"},     {"kk", "icu"},    {"kl", "icu"},    {"km", "icu"},
+    {"kn", "icu"},    {"ko", "icu"},    {"kok", "icu"},    {"ku", "icu"},    {"ky", "icu"},    {"lb", "icu"},
+    {"lkt", "icu"},   {"ln", "icu"},    {"lo", "icu"},     {"lt", "icu"},    {"lv", "icu"},    {"mk", "icu"},
+    {"ml", "icu"},    {"mn", "icu"},    {"mr", "icu"},     {"ms", "icu"},    {"mt", "icu"},    {"my", "icu"},
+    {"nb", "icu"},    {"nb_no", "icu"}, {"ne", "icu"},     {"nl", "icu"},    {"nn", "icu"},    {"om", "icu"},
+    {"or", "icu"},    {"pa", "icu"},    {"pa_in", "icu"},  {"pl", "icu"},    {"ps", "icu"},    {"pt", "icu"},
+    {"ro", "icu"},    {"ru", "icu"},    {"sa", "icu"},     {"se", "icu"},    {"si", "icu"},    {"sk", "icu"},
+    {"sl", "icu"},    {"smn", "icu"},   {"sq", "icu"},     {"sr", "icu"},    {"sr_ba", "icu"}, {"sr_me", "icu"},
+    {"sr_rs", "icu"}, {"sv", "icu"},    {"sw", "icu"},     {"ta", "icu"},    {"te", "icu"},    {"th", "icu"},
+    {"tk", "icu"},    {"to", "icu"},    {"tr", "icu"},     {"ug", "icu"},    {"uk", "icu"},    {"ur", "icu"},
+    {"uz", "icu"},    {"vi", "icu"},    {"wae", "icu"},    {"wo", "icu"},    {"xh", "icu"},    {"yi", "icu"},
+    {"yo", "icu"},    {"yue", "icu"},   {"yue_cn", "icu"}, {"zh", "icu"},    {"zh_cn", "icu"}, {"zh_hk", "icu"},
+    {"zh_mo", "icu"}, {"zh_sg", "icu"}, {"zh_tw", "icu"},  {"zu", "icu"}}; // END_OF_EXTENSION_COLLATIONS
+
 // Note: these are currently hardcoded in scripts/generate_extensions_function.py
 // TODO: automate by passing though to script via duckdb
 static constexpr ExtensionEntry EXTENSION_FILE_PREFIXES[] = {

package/src/duckdb/src/include/duckdb/main/extension_util.hpp

@@ -14,6 +14,7 @@
 
 namespace duckdb {
 struct CreateMacroInfo;
+struct CreateCollationInfo;
 class DatabaseInstance;
 
 //! The ExtensionUtil class contains methods that are useful for extensions
@@ -40,6 +41,19 @@ public:
 	//! Register a new macro function - throw an exception if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateMacroInfo &info);
 
+	//! Register a new collation
+	DUCKDB_API static void RegisterCollation(DatabaseInstance &db, CreateCollationInfo &info);
+
+	//! Returns a reference to the function in the catalog - throws an exception if it does not exist
+	DUCKDB_API static ScalarFunctionCatalogEntry &GetFunction(DatabaseInstance &db, const string &name);
+	DUCKDB_API static TableFunctionCatalogEntry &GetTableFunction(DatabaseInstance &db, const string &name);
+
+	//! Add a function overload
+	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, ScalarFunction function);
+	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, ScalarFunctionSet function);
+
+	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, TableFunctionSet function);
+
 	//! Registers a new type
 	DUCKDB_API static void RegisterType(DatabaseInstance &db, string type_name, LogicalType type);
 

package/src/duckdb/src/main/extension/extension_util.cpp

@@ -7,6 +7,9 @@
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
+#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
+#include "duckdb/parser/parsed_data/create_collation_info.hpp"
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/main/config.hpp"
 
@@ -86,6 +89,59 @@ void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateMacroInfo &info
 	system_catalog.CreateFunction(data, info);
 }
 
+void ExtensionUtil::RegisterCollation(DatabaseInstance &db, CreateCollationInfo &info) {
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	info.on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
+	system_catalog.CreateCollation(data, info);
+}
+
+void ExtensionUtil::AddFunctionOverload(DatabaseInstance &db, ScalarFunction function) {
+	auto &scalar_function = ExtensionUtil::GetFunction(db, function.name);
+	scalar_function.functions.AddFunction(std::move(function));
+}
+
+void ExtensionUtil::AddFunctionOverload(DatabaseInstance &db, ScalarFunctionSet functions) { // NOLINT
+	D_ASSERT(!functions.name.empty());
+	auto &scalar_function = ExtensionUtil::GetFunction(db, functions.name);
+	for (auto &function : functions.functions) {
+		function.name = functions.name;
+		scalar_function.functions.AddFunction(std::move(function));
+	}
+}
+
+void ExtensionUtil::AddFunctionOverload(DatabaseInstance &db, TableFunctionSet functions) { // NOLINT
+	auto &table_function = ExtensionUtil::GetTableFunction(db, functions.name);
+	for (auto &function : functions.functions) {
+		function.name = functions.name;
+		table_function.functions.AddFunction(std::move(function));
+	}
+}
+
+ScalarFunctionCatalogEntry &ExtensionUtil::GetFunction(DatabaseInstance &db, const string &name) {
+	D_ASSERT(!name.empty());
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	auto &schema = system_catalog.GetSchema(data, DEFAULT_SCHEMA);
+	auto catalog_entry = schema.GetEntry(data, CatalogType::SCALAR_FUNCTION_ENTRY, name);
+	if (!catalog_entry) {
+		throw InvalidInputException("Function with name \"%s\" not found in ExtensionUtil::GetFunction", name);
+	}
+	return catalog_entry->Cast<ScalarFunctionCatalogEntry>();
+}
+
+TableFunctionCatalogEntry &ExtensionUtil::GetTableFunction(DatabaseInstance &db, const string &name) {
+	D_ASSERT(!name.empty());
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	auto &schema = system_catalog.GetSchema(data, DEFAULT_SCHEMA);
+	auto catalog_entry = schema.GetEntry(data, CatalogType::TABLE_FUNCTION_ENTRY, name);
+	if (!catalog_entry) {
+		throw InvalidInputException("Function with name \"%s\" not found in ExtensionUtil::GetTableFunction", name);
+	}
+	return catalog_entry->Cast<TableFunctionCatalogEntry>();
+}
+
 void ExtensionUtil::RegisterType(DatabaseInstance &db, string type_name, LogicalType type) {
 	D_ASSERT(!type_name.empty());
 	CreateTypeInfo info(std::move(type_name), std::move(type));