duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

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"
@@ -198,7 +199,7 @@ struct ICUDateAdd : public ICUDateFunc {
 		D_ASSERT(args.ColumnCount() == 1);
 
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = (BindData &)*func_expr.bind_info;
+		auto &info = func_expr.bind_info->Cast<BindData>();
 		CalendarPtr calendar(info.calendar->clone());
 
 		auto end_date = Timestamp::GetCurrentTimestamp();
@@ -218,7 +219,7 @@ struct ICUDateAdd : public ICUDateFunc {
 		D_ASSERT(args.ColumnCount() == 2);
 
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = (BindData &)*func_expr.bind_info;
+		auto &info = func_expr.bind_info->Cast<BindData>();
 		CalendarPtr calendar(info.calendar->clone());
 
 		BinaryExecutor::Execute<TA, TB, TR>(args.data[0], args.data[1], result, args.size(), [&](TA left, TB right) {
@@ -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-datefunc.cpp

@@ -5,6 +5,8 @@
 #include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 
+#include "unicode/ucal.h"
+
 namespace duckdb {
 
 ICUDateFunc::BindData::BindData(const BindData &other)
@@ -34,10 +36,17 @@ ICUDateFunc::BindData::BindData(ClientContext &context) {
 	if (U_FAILURE(success)) {
 		throw Exception("Unable to create ICU calendar.");
 	}
+
+	//	Postgres always assumes times are given in the proleptic Gregorian calendar.
+	//	ICU defaults to the Gregorian change in 1582, so we reset the change to the minimum date
+	//	so that all dates are proleptic Gregorian.
+	//	The only error here is if we have a non-Gregorian calendar,
+	//	and we just ignore that and hope for the best...
+	ucal_setGregorianChange((UCalendar *)calendar.get(), U_DATE_MIN, &success); // NOLINT
 }
 
 bool ICUDateFunc::BindData::Equals(const FunctionData &other_p) const {
-	auto &other = (const ICUDateFunc::BindData &)other_p;
+	auto &other = other_p.Cast<const BindData>();
 	return *calendar == *other.calendar;
 }
 

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"
@@ -14,7 +15,8 @@
 namespace duckdb {
 
 struct ICUDatePart : public ICUDateFunc {
-	typedef int64_t (*part_adapter_t)(icu::Calendar *calendar, const uint64_t micros);
+	typedef int64_t (*part_bigint_t)(icu::Calendar *calendar, const uint64_t micros);
+	typedef double (*part_double_t)(icu::Calendar *calendar, const uint64_t micros);
 
 	// Date part adapters
 	static int64_t ExtractEra(icu::Calendar *calendar, const uint64_t micros) {
@@ -54,13 +56,13 @@ struct ICUDatePart : public ICUDateFunc {
 	}
 
 	static int64_t ExtractDayOfWeek(icu::Calendar *calendar, const uint64_t micros) {
-		calendar->setFirstDayOfWeek(UCAL_SUNDAY);
+		// [Sun(0), Sat(6)]
 		return ExtractField(calendar, UCAL_DAY_OF_WEEK) - UCAL_SUNDAY;
 	}
 
 	static int64_t ExtractISODayOfWeek(icu::Calendar *calendar, const uint64_t micros) {
-		calendar->setFirstDayOfWeek(UCAL_MONDAY);
-		return ExtractField(calendar, UCAL_DAY_OF_WEEK);
+		// [Mon(1), Sun(7)]
+		return 1 + (ExtractField(calendar, UCAL_DAY_OF_WEEK) + 7 - UCAL_MONDAY) % 7;
 	}
 
 	static int64_t ExtractWeek(icu::Calendar *calendar, const uint64_t micros) {
@@ -107,13 +109,11 @@ struct ICUDatePart : public ICUDateFunc {
 		return ExtractMillisecond(calendar, micros) * Interval::MICROS_PER_MSEC + micros;
 	}
 
-	static int64_t ExtractEpoch(icu::Calendar *calendar, const uint64_t micros) {
+	static double ExtractEpoch(icu::Calendar *calendar, const uint64_t micros) {
 		UErrorCode status = U_ZERO_ERROR;
-		auto millis = calendar->getTime(status);
-		millis += ExtractField(calendar, UCAL_ZONE_OFFSET);
-		millis += ExtractField(calendar, UCAL_DST_OFFSET);
-		//	Truncate
-		return millis / Interval::MSECS_PER_SEC;
+		auto result = calendar->getTime(status) / Interval::MSECS_PER_SEC;
+		result += micros / double(Interval::MICROS_PER_SEC);
+		return result;
 	}
 
 	static int64_t ExtractTimezone(icu::Calendar *calendar, const uint64_t micros) {
@@ -132,7 +132,26 @@ struct ICUDatePart : public ICUDateFunc {
 		return (secs % Interval::SECS_PER_HOUR) / Interval::SECS_PER_MINUTE;
 	}
 
-	static part_adapter_t PartCodeAdapterFactory(DatePartSpecifier part) {
+	//	PG uses doubles for JDs so we can only use them with other double types
+	static double ExtractJulianDay(icu::Calendar *calendar, const uint64_t micros) {
+		//	We need days + fraction
+		auto days = ExtractField(calendar, UCAL_JULIAN_DAY);
+		auto frac = ExtractHour(calendar, micros);
+
+		frac *= Interval::MINS_PER_HOUR;
+		frac += ExtractMinute(calendar, micros);
+
+		frac *= Interval::MICROS_PER_MINUTE;
+		frac += ExtractMicrosecond(calendar, micros);
+
+		double result = frac;
+		result /= Interval::MICROS_PER_DAY;
+		result += days;
+
+		return result;
+	}
+
+	static part_bigint_t PartCodeBigintFactory(DatePartSpecifier part) {
 		switch (part) {
 		case DatePartSpecifier::YEAR:
 			return ExtractYear;
@@ -170,8 +189,6 @@ struct ICUDatePart : public ICUDateFunc {
 			return ExtractQuarter;
 		case DatePartSpecifier::YEARWEEK:
 			return ExtractYearWeek;
-		case DatePartSpecifier::EPOCH:
-			return ExtractEpoch;
 		case DatePartSpecifier::ERA:
 			return ExtractEra;
 		case DatePartSpecifier::TIMEZONE:
@@ -181,7 +198,18 @@ struct ICUDatePart : public ICUDateFunc {
 		case DatePartSpecifier::TIMEZONE_MINUTE:
 			return ExtractTimezoneMinute;
 		default:
-			throw Exception("Unsupported ICU extract adapter");
+			throw Exception("Unsupported ICU BIGINT extractor");
+		}
+	}
+
+	static part_double_t PartCodeDoubleFactory(DatePartSpecifier part) {
+		switch (part) {
+		case DatePartSpecifier::EPOCH:
+			return ExtractEpoch;
+		case DatePartSpecifier::JULIAN_DAY:
+			return ExtractJulianDay;
+		default:
+			throw Exception("Unsupported ICU DOUBLE extractor");
 		}
 	}
 
@@ -200,13 +228,18 @@ struct ICUDatePart : public ICUDateFunc {
 
 		calendar->set(UCAL_DATE, dd);
 
-		return Date::EpochToDate(ExtractEpoch(calendar, 0));
+		//	Offset to UTC
+		auto millis = calendar->getTime(status);
+		millis += ExtractField(calendar, UCAL_ZONE_OFFSET);
+		millis += ExtractField(calendar, UCAL_DST_OFFSET);
+
+		return Date::EpochToDate(millis / Interval::MSECS_PER_SEC);
 	}
 
 	static string_t MonthName(icu::Calendar *calendar, const uint64_t micros) {
 		const auto mm = ExtractMonth(calendar, micros) - 1;
 		if (mm == 12) {
-			return "Undecember";
+			return "Undecimber";
 		}
 		return Date::MONTH_NAMES[mm];
 	}
@@ -231,7 +264,7 @@ struct ICUDatePart : public ICUDateFunc {
 		adapters_t adapters;
 
 		bool Equals(const FunctionData &other_p) const override {
-			const auto &other = (BindAdapterData &)other_p;
+			const auto &other = other_p.Cast<BindAdapterData>();
 			return BindData::Equals(other_p) && adapters == other.adapters;
 		}
 
@@ -247,7 +280,7 @@ struct ICUDatePart : public ICUDateFunc {
 		auto &date_arg = args.data[0];
 
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = (BIND_TYPE &)*func_expr.bind_info;
+		auto &info = func_expr.bind_info->Cast<BIND_TYPE>();
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
 
@@ -271,7 +304,7 @@ struct ICUDatePart : public ICUDateFunc {
 		auto &date_arg = args.data[1];
 
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = (BIND_TYPE &)*func_expr.bind_info;
+		auto &info = func_expr.bind_info->Cast<BIND_TYPE>();
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
 
@@ -280,7 +313,7 @@ struct ICUDatePart : public ICUDateFunc {
 		    [&](string_t specifier, INPUT_TYPE input, ValidityMask &mask, idx_t idx) {
 			    if (Timestamp::IsFinite(input)) {
 				    const auto micros = SetTime(calendar, input);
-				    auto adapter = PartCodeAdapterFactory(GetDatePartSpecifier(specifier.GetString()));
+				    auto adapter = PartCodeBigintFactory(GetDatePartSpecifier(specifier.GetString()));
 				    return adapter(calendar, micros);
 			    } else {
 				    mask.SetInvalid(idx);
@@ -289,11 +322,37 @@ struct ICUDatePart : public ICUDateFunc {
 		    });
 	}
 
+	struct BindStructData : public BindData {
+		using part_codes_t = vector<DatePartSpecifier>;
+		using bigints_t = vector<part_bigint_t>;
+		using doubles_t = vector<part_double_t>;
+
+		BindStructData(ClientContext &context, part_codes_t &part_codes_p, bigints_t &bigints_p, doubles_t &doubles_p)
+		    : BindData(context), part_codes(part_codes_p), bigints(bigints_p), doubles(doubles_p) {
+		}
+		BindStructData(const BindStructData &other)
+		    : BindData(other), part_codes(other.part_codes), bigints(other.bigints), doubles(other.doubles) {
+		}
+
+		part_codes_t part_codes;
+		bigints_t bigints;
+		doubles_t doubles;
+
+		bool Equals(const FunctionData &other_p) const override {
+			const auto &other = other_p.Cast<BindStructData>();
+			return BindData::Equals(other_p) && part_codes == other.part_codes && bigints == other.bigints &&
+			       doubles == other.doubles;
+		}
+
+		duckdb::unique_ptr<FunctionData> Copy() const override {
+			return make_uniq<BindStructData>(*this);
+		}
+	};
+
 	template <typename INPUT_TYPE>
 	static void StructFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-		using BIND_TYPE = BindAdapterData<int64_t>;
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = (BIND_TYPE &)*func_expr.bind_info;
+		auto &info = func_expr.bind_info->Cast<BindStructData>();
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
 
@@ -316,9 +375,15 @@ struct ICUDatePart : public ICUDateFunc {
 					auto &child_entry = child_entries[col];
 					if (is_finite) {
 						ConstantVector::SetNull(*child_entry, false);
-						auto pdata = ConstantVector::GetData<int64_t>(*child_entry);
-						auto adapter = info.adapters[col];
-						pdata[0] = adapter(calendar, micros);
+						if (IsBigintDatepart(info.part_codes[col])) {
+							auto pdata = ConstantVector::GetData<int64_t>(*child_entry);
+							auto adapter = info.bigints[col];
+							pdata[0] = adapter(calendar, micros);
+						} else {
+							auto pdata = ConstantVector::GetData<double>(*child_entry);
+							auto adapter = info.doubles[col];
+							pdata[0] = adapter(calendar, micros);
+						}
 					} else {
 						ConstantVector::SetNull(*child_entry, true);
 					}
@@ -348,9 +413,15 @@ struct ICUDatePart : public ICUDateFunc {
 						auto &child_entry = child_entries[col];
 						if (is_finite) {
 							FlatVector::Validity(*child_entry).SetValid(i);
-							auto pdata = FlatVector::GetData<int64_t>(*child_entry);
-							auto adapter = info.adapters[col];
-							pdata[i] = adapter(calendar, micros);
+							if (IsBigintDatepart(info.part_codes[col])) {
+								auto pdata = ConstantVector::GetData<int64_t>(*child_entry);
+								auto adapter = info.bigints[col];
+								pdata[i] = adapter(calendar, micros);
+							} else {
+								auto pdata = ConstantVector::GetData<double>(*child_entry);
+								auto adapter = info.doubles[col];
+								pdata[i] = adapter(calendar, micros);
+							}
 						} else {
 							FlatVector::Validity(*child_entry).SetInvalid(i);
 						}
@@ -374,19 +445,54 @@ struct ICUDatePart : public ICUDateFunc {
 		return make_uniq<BIND_TYPE>(context, adapter);
 	}
 
-	static duckdb::unique_ptr<FunctionData> BindDatePart(ClientContext &context, ScalarFunction &bound_function,
-	                                                     vector<duckdb::unique_ptr<Expression>> &arguments) {
+	static duckdb::unique_ptr<FunctionData> BindUnaryDatePart(ClientContext &context, ScalarFunction &bound_function,
+	                                                          vector<duckdb::unique_ptr<Expression>> &arguments) {
+		const auto part_code = GetDatePartSpecifier(bound_function.name);
+		if (IsBigintDatepart(part_code)) {
+			using data_t = BindAdapterData<int64_t>;
+			auto adapter = PartCodeBigintFactory(part_code);
+			return BindAdapter<data_t>(context, bound_function, arguments, adapter);
+		} else {
+			using data_t = BindAdapterData<double>;
+			auto adapter = PartCodeDoubleFactory(part_code);
+			return BindAdapter<data_t>(context, bound_function, arguments, adapter);
+		}
+	}
+
+	static duckdb::unique_ptr<FunctionData> BindBinaryDatePart(ClientContext &context, ScalarFunction &bound_function,
+	                                                           vector<duckdb::unique_ptr<Expression>> &arguments) {
+		//	If we are only looking for Julian Days, then patch in the unary function.
+		do {
+			if (arguments[0]->HasParameter() || !arguments[0]->IsFoldable()) {
+				break;
+			}
+
+			Value part_value = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
+			if (part_value.IsNull()) {
+				break;
+			}
+
+			const auto part_name = part_value.ToString();
+			const auto part_code = GetDatePartSpecifier(part_name);
+			if (IsBigintDatepart(part_code)) {
+				break;
+			}
+
+			arguments.erase(arguments.begin());
+			bound_function.arguments.erase(bound_function.arguments.begin());
+			bound_function.name = part_name;
+			bound_function.return_type = LogicalType::DOUBLE;
+			bound_function.function = UnaryTimestampFunction<timestamp_t, double>;
+
+			return BindUnaryDatePart(context, bound_function, arguments);
+		} while (false);
+
 		using data_t = BindAdapterData<int64_t>;
-		auto adapter =
-		    (arguments.size() == 1) ? PartCodeAdapterFactory(GetDatePartSpecifier(bound_function.name)) : nullptr;
-		return BindAdapter<data_t>(context, bound_function, arguments, adapter);
+		return BindAdapter<data_t>(context, bound_function, arguments, nullptr);
 	}
 
 	static duckdb::unique_ptr<FunctionData> BindStruct(ClientContext &context, ScalarFunction &bound_function,
 	                                                   vector<duckdb::unique_ptr<Expression>> &arguments) {
-		using data_t = BindAdapterData<int64_t>;
-		using adapters_t = data_t::adapters_t;
-
 		// collect names and deconflict, construct return type
 		if (arguments[0]->HasParameter()) {
 			throw ParameterNotResolvedException();
@@ -397,7 +503,9 @@ struct ICUDatePart : public ICUDateFunc {
 
 		case_insensitive_set_t name_collision_set;
 		child_list_t<LogicalType> struct_children;
-		adapters_t adapters;
+		BindStructData::part_codes_t part_codes;
+		BindStructData::bigints_t bigints;
+		BindStructData::doubles_t doubles;
 
 		Value parts_list = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
 		if (parts_list.type().id() == LogicalTypeId::LIST) {
@@ -405,7 +513,11 @@ struct ICUDatePart : public ICUDateFunc {
 			if (list_children.empty()) {
 				throw BinderException("%s requires non-empty lists of part names", bound_function.name);
 			}
-			for (const auto &part_value : list_children) {
+
+			bigints.resize(list_children.size(), nullptr);
+			doubles.resize(list_children.size(), nullptr);
+			for (size_t col = 0; col < list_children.size(); ++col) {
+				const auto &part_value = list_children[col];
 				if (part_value.IsNull()) {
 					throw BinderException("NULL struct entry name in %s", bound_function.name);
 				}
@@ -415,8 +527,14 @@ struct ICUDatePart : public ICUDateFunc {
 					throw BinderException("Duplicate struct entry name \"%s\" in %s", part_name, bound_function.name);
 				}
 				name_collision_set.insert(part_name);
-				adapters.emplace_back(PartCodeAdapterFactory(part_code));
-				struct_children.emplace_back(make_pair(part_name, LogicalType::BIGINT));
+				part_codes.emplace_back(part_code);
+				if (IsBigintDatepart(part_code)) {
+					bigints[col] = PartCodeBigintFactory(part_code);
+					struct_children.emplace_back(make_pair(part_name, LogicalType::BIGINT));
+				} else {
+					doubles[col] = PartCodeDoubleFactory(part_code);
+					struct_children.emplace_back(make_pair(part_name, LogicalType::DOUBLE));
+				}
 			}
 		} else {
 			throw BinderException("%s can only take constant lists of part names", bound_function.name);
@@ -424,37 +542,38 @@ struct ICUDatePart : public ICUDateFunc {
 
 		Function::EraseArgument(bound_function, arguments, 0);
 		bound_function.return_type = LogicalType::STRUCT(std::move(struct_children));
-		return make_uniq<data_t>(context, adapters);
+		return make_uniq<BindStructData>(context, part_codes, bigints, doubles);
 	}
 
-	static void SerializeFunction(FieldWriter &writer, const FunctionData *bind_data_p,
+	static void SerializeFunction(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
 	                              const ScalarFunction &function) {
 		throw NotImplementedException("FIXME: serialize icu-datepart");
 	}
 
-	static duckdb::unique_ptr<FunctionData> DeserializeFunction(PlanDeserializationState &state, FieldReader &reader,
+	static duckdb::unique_ptr<FunctionData> DeserializeFunction(Deserializer &deserializer,
 	                                                            ScalarFunction &bound_function) {
 		throw NotImplementedException("FIXME: serialize icu-datepart");
 	}
 
 	template <typename INPUT_TYPE, typename RESULT_TYPE>
-	static ScalarFunction GetUnaryPartCodeFunction(const LogicalType &temporal_type) {
-		return ScalarFunction({temporal_type}, LogicalType::BIGINT, UnaryTimestampFunction<INPUT_TYPE, RESULT_TYPE>,
-		                      BindDatePart);
+	static ScalarFunction GetUnaryPartCodeFunction(const LogicalType &temporal_type,
+	                                               const LogicalType &result_type = LogicalType::BIGINT) {
+		return ScalarFunction({temporal_type}, result_type, UnaryTimestampFunction<INPUT_TYPE, RESULT_TYPE>,
+		                      BindUnaryDatePart);
 	}
 
-	static void AddUnaryPartCodeFunctions(const string &name, ClientContext &context) {
-		auto &catalog = Catalog::GetSystemCatalog(context);
+	template <typename RESULT_TYPE = int64_t>
+	static void AddUnaryPartCodeFunctions(const string &name, DatabaseInstance &db,
+	                                      const LogicalType &result_type = LogicalType::BIGINT) {
 		ScalarFunctionSet set(name);
-		set.AddFunction(GetUnaryPartCodeFunction<timestamp_t, int64_t>(LogicalType::TIMESTAMP_TZ));
-		CreateScalarFunctionInfo func_info(set);
-		catalog.AddFunction(context, func_info);
+		set.AddFunction(GetUnaryPartCodeFunction<timestamp_t, RESULT_TYPE>(LogicalType::TIMESTAMP_TZ, result_type));
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 
 	template <typename INPUT_TYPE, typename RESULT_TYPE>
 	static ScalarFunction GetBinaryPartCodeFunction(const LogicalType &temporal_type) {
 		return ScalarFunction({LogicalType::VARCHAR, temporal_type}, LogicalType::BIGINT,
-		                      BinaryTimestampFunction<INPUT_TYPE, RESULT_TYPE>, BindDatePart);
+		                      BinaryTimestampFunction<INPUT_TYPE, RESULT_TYPE>, BindBinaryDatePart);
 	}
 
 	template <typename INPUT_TYPE>
@@ -467,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,
@@ -487,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,
@@ -506,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,
@@ -525,58 +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
-	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("epoch", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("isoyear", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("timezone", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("timezone_hour", context);
-	ICUDatePart::AddUnaryPartCodeFunctions("timezone_minute", context);
+
+	//	BIGINTs
+	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", 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