duckdb 0.8.2-dev77.0 → 0.9.0

package/src/duckdb/src/core_functions/scalar/date/date_part.cpp

@@ -11,8 +11,6 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType &type) {
@@ -37,6 +35,8 @@ DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType
 		case DatePartSpecifier::DOY:
 		case DatePartSpecifier::YEARWEEK:
 		case DatePartSpecifier::ERA:
+		case DatePartSpecifier::EPOCH:
+		case DatePartSpecifier::JULIAN_DAY:
 			return part;
 		default:
 			break;
@@ -97,8 +97,9 @@ static unique_ptr<BaseStatistics> PropagateSimpleDatePartStatistics(vector<BaseS
 }
 
 struct DatePart {
-	template <class T, class OP>
-	static unique_ptr<BaseStatistics> PropagateDatePartStatistics(vector<BaseStatistics> &child_stats) {
+	template <class T, class OP, class TR = int64_t>
+	static unique_ptr<BaseStatistics> PropagateDatePartStatistics(vector<BaseStatistics> &child_stats,
+	                                                              const LogicalType &stats_type = LogicalType::BIGINT) {
 		// we can only propagate complex date part stats if the child has stats
 		auto &nstats = child_stats[0];
 		if (!NumericStats::HasMinMax(nstats)) {
@@ -114,11 +115,11 @@ struct DatePart {
 		if (!Value::IsFinite(min) || !Value::IsFinite(max)) {
 			return nullptr;
 		}
-		auto min_part = OP::template Operation<T, int64_t>(min);
-		auto max_part = OP::template Operation<T, int64_t>(max);
-		auto result = NumericStats::CreateEmpty(LogicalType::BIGINT);
-		NumericStats::SetMin(result, Value::BIGINT(min_part));
-		NumericStats::SetMax(result, Value::BIGINT(max_part));
+		TR min_part = OP::template Operation<T, TR>(min);
+		TR max_part = OP::template Operation<T, TR>(max);
+		auto result = NumericStats::CreateEmpty(stats_type);
+		NumericStats::SetMin(result, Value(min_part));
+		NumericStats::SetMax(result, Value(max_part));
 		result.CopyValidity(child_stats[0]);
 		return result.ToUnique();
 	}
@@ -354,6 +355,49 @@ struct DatePart {
 		}
 	};
 
+	struct EpochNanosecondsOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			return input.micros * Interval::NANOS_PER_MICRO;
+		}
+
+		template <class T>
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, EpochNanosecondsOperator>(input.child_stats);
+		}
+	};
+
+	struct EpochMicrosecondsOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			return input.micros;
+		}
+
+		template <class T>
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, EpochMicrosecondsOperator>(input.child_stats);
+		}
+	};
+
+	struct EpochMillisOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			return input.micros / Interval::MICROS_PER_MSEC;
+		}
+
+		template <class T>
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, EpochMillisOperator>(input.child_stats);
+		}
+
+		static void Inverse(DataChunk &input, ExpressionState &state, Vector &result) {
+			D_ASSERT(input.ColumnCount() == 1);
+
+			UnaryExecutor::Execute<int64_t, timestamp_t>(input.data[0], result, input.size(),
+			                                             [&](int64_t input) { return Timestamp::FromEpochMs(input); });
+		}
+	};
+
 	struct MicrosecondsOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
@@ -422,7 +466,7 @@ struct DatePart {
 
 		template <class T>
 		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, EpochOperator>(input.child_stats);
+			return PropagateDatePartStatistics<T, EpochOperator, double>(input.child_stats, LogicalType::DOUBLE);
 		}
 	};
 
@@ -456,6 +500,18 @@ struct DatePart {
 		}
 	};
 
+	struct JulianDayOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			return Timestamp::GetJulianDay(input);
+		}
+
+		template <class T>
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, JulianDayOperator, double>(input.child_stats, LogicalType::DOUBLE);
+		}
+	};
+
 	// These are all zero and have the same restrictions
 	using TimezoneHourOperator = TimezoneOperator;
 	using TimezoneMinuteOperator = TimezoneOperator;
@@ -471,7 +527,8 @@ struct DatePart {
 			EPOCH = 1 << 3,
 			TIME = 1 << 4,
 			ZONE = 1 << 5,
-			ISO = 1 << 6
+			ISO = 1 << 6,
+			JD = 1 << 7
 		};
 
 		static part_mask_t GetMask(const part_codes_t &part_codes) {
@@ -503,6 +560,9 @@ struct DatePart {
 				case DatePartSpecifier::EPOCH:
 					mask |= EPOCH;
 					break;
+				case DatePartSpecifier::JULIAN_DAY:
+					mask |= JD;
+					break;
 				case DatePartSpecifier::MICROSECONDS:
 				case DatePartSpecifier::MILLISECONDS:
 				case DatePartSpecifier::SECOND:
@@ -515,60 +575,80 @@ struct DatePart {
 				case DatePartSpecifier::TIMEZONE_MINUTE:
 					mask |= ZONE;
 					break;
+				case DatePartSpecifier::INVALID:
+					throw InternalException("Invalid DatePartSpecifier for STRUCT mask!");
 				}
 			}
 			return mask;
 		}
 
 		template <typename P>
-		static inline bool HasPartValue(P *part_values, DatePartSpecifier part, P &value) {
-			value = part_values[int(part)];
-			return value;
+		static inline P HasPartValue(vector<P> part_values, DatePartSpecifier part) {
+			auto idx = size_t(part);
+			if (IsBigintDatepart(part)) {
+				return part_values[idx - size_t(DatePartSpecifier::BEGIN_BIGINT)];
+			} else {
+				return part_values[idx - size_t(DatePartSpecifier::BEGIN_DOUBLE)];
+			}
 		}
 
-		template <class TA, class TR>
-		static inline void Operation(TR **part_values, const TA &input, const idx_t idx, const part_mask_t mask) {
-			TR *part_data;
+		using bigint_vec = vector<int64_t *>;
+		using double_vec = vector<double *>;
+
+		template <class TA>
+		static inline void Operation(bigint_vec &bigint_values, double_vec &double_values, const TA &input,
+		                             const idx_t idx, const part_mask_t mask) {
+			int64_t *bigint_data;
 			// YMD calculations
 			int32_t yyyy = 1970;
 			int32_t mm = 0;
 			int32_t dd = 1;
 			if (mask & YMD) {
 				Date::Convert(input, yyyy, mm, dd);
-				if (HasPartValue(part_values, DatePartSpecifier::YEAR, part_data)) {
-					part_data[idx] = yyyy;
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::YEAR);
+				if (bigint_data) {
+					bigint_data[idx] = yyyy;
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::MONTH, part_data)) {
-					part_data[idx] = mm;
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::MONTH);
+				if (bigint_data) {
+					bigint_data[idx] = mm;
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::DAY, part_data)) {
-					part_data[idx] = dd;
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::DAY);
+				if (bigint_data) {
+					bigint_data[idx] = dd;
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::DECADE, part_data)) {
-					part_data[idx] = DecadeOperator::DecadeFromYear(yyyy);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::DECADE);
+				if (bigint_data) {
+					bigint_data[idx] = DecadeOperator::DecadeFromYear(yyyy);
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::CENTURY, part_data)) {
-					part_data[idx] = CenturyOperator::CenturyFromYear(yyyy);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::CENTURY);
+				if (bigint_data) {
+					bigint_data[idx] = CenturyOperator::CenturyFromYear(yyyy);
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::MILLENNIUM, part_data)) {
-					part_data[idx] = MillenniumOperator::MillenniumFromYear(yyyy);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::MILLENNIUM);
+				if (bigint_data) {
+					bigint_data[idx] = MillenniumOperator::MillenniumFromYear(yyyy);
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::QUARTER, part_data)) {
-					part_data[idx] = QuarterOperator::QuarterFromMonth(mm);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::QUARTER);
+				if (bigint_data) {
+					bigint_data[idx] = QuarterOperator::QuarterFromMonth(mm);
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::ERA, part_data)) {
-					part_data[idx] = EraOperator::EraFromYear(yyyy);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::ERA);
+				if (bigint_data) {
+					bigint_data[idx] = EraOperator::EraFromYear(yyyy);
 				}
 			}
 
 			// Week calculations
 			if (mask & DOW) {
 				auto isodow = Date::ExtractISODayOfTheWeek(input);
-				if (HasPartValue(part_values, DatePartSpecifier::DOW, part_data)) {
-					part_data[idx] = DayOfWeekOperator::DayOfWeekFromISO(isodow);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::DOW);
+				if (bigint_data) {
+					bigint_data[idx] = DayOfWeekOperator::DayOfWeekFromISO(isodow);
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::ISODOW, part_data)) {
-					part_data[idx] = isodow;
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::ISODOW);
+				if (bigint_data) {
+					bigint_data[idx] = isodow;
 				}
 			}
 
@@ -577,25 +657,36 @@ struct DatePart {
 				int32_t ww = 0;
 				int32_t iyyy = 0;
 				Date::ExtractISOYearWeek(input, iyyy, ww);
-				if (HasPartValue(part_values, DatePartSpecifier::WEEK, part_data)) {
-					part_data[idx] = ww;
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::WEEK);
+				if (bigint_data) {
+					bigint_data[idx] = ww;
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::ISOYEAR, part_data)) {
-					part_data[idx] = iyyy;
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::ISOYEAR);
+				if (bigint_data) {
+					bigint_data[idx] = iyyy;
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::YEARWEEK, part_data)) {
-					part_data[idx] = YearWeekOperator::YearWeekFromParts(iyyy, ww);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::YEARWEEK);
+				if (bigint_data) {
+					bigint_data[idx] = YearWeekOperator::YearWeekFromParts(iyyy, ww);
 				}
 			}
 
 			if (mask & EPOCH) {
-				if (HasPartValue(part_values, DatePartSpecifier::EPOCH, part_data)) {
-					part_data[idx] = Date::Epoch(input);
+				auto double_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
+				if (double_data) {
+					double_data[idx] = Date::Epoch(input);
 				}
 			}
 			if (mask & DOY) {
-				if (HasPartValue(part_values, DatePartSpecifier::DOY, part_data)) {
-					part_data[idx] = Date::ExtractDayOfTheYear(input);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::DOY);
+				if (bigint_data) {
+					bigint_data[idx] = Date::ExtractDayOfTheYear(input);
+				}
+			}
+			if (mask & JD) {
+				auto double_data = HasPartValue(double_values, DatePartSpecifier::JULIAN_DAY);
+				if (double_data) {
+					double_data[idx] = Date::ExtractJulianDay(input);
 				}
 			}
 		}
@@ -798,6 +889,51 @@ int64_t DatePart::YearWeekOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"yearweek\" not recognized");
 }
 
+template <>
+int64_t DatePart::EpochNanosecondsOperator::Operation(timestamp_t input) {
+	return Timestamp::GetEpochNanoSeconds(input);
+}
+
+template <>
+int64_t DatePart::EpochNanosecondsOperator::Operation(date_t input) {
+	return Date::EpochNanoseconds(input);
+}
+
+template <>
+int64_t DatePart::EpochNanosecondsOperator::Operation(interval_t input) {
+	return Interval::GetNanoseconds(input);
+}
+
+template <>
+int64_t DatePart::EpochMicrosecondsOperator::Operation(timestamp_t input) {
+	return Timestamp::GetEpochMicroSeconds(input);
+}
+
+template <>
+int64_t DatePart::EpochMicrosecondsOperator::Operation(date_t input) {
+	return Date::EpochMicroseconds(input);
+}
+
+template <>
+int64_t DatePart::EpochMicrosecondsOperator::Operation(interval_t input) {
+	return Interval::GetMicro(input);
+}
+
+template <>
+int64_t DatePart::EpochMillisOperator::Operation(timestamp_t input) {
+	return Timestamp::GetEpochMs(input);
+}
+
+template <>
+int64_t DatePart::EpochMillisOperator::Operation(date_t input) {
+	return Date::EpochMilliseconds(input);
+}
+
+template <>
+int64_t DatePart::EpochMillisOperator::Operation(interval_t input) {
+	return Interval::GetMilli(input);
+}
+
 template <>
 int64_t DatePart::MicrosecondsOperator::Operation(timestamp_t input) {
 	auto time = Timestamp::GetTime(input);
@@ -882,12 +1018,12 @@ int64_t DatePart::HoursOperator::Operation(dtime_t input) {
 }
 
 template <>
-int64_t DatePart::EpochOperator::Operation(timestamp_t input) {
-	return Timestamp::GetEpochSeconds(input);
+double DatePart::EpochOperator::Operation(timestamp_t input) {
+	return Timestamp::GetEpochMicroSeconds(input) / double(Interval::MICROS_PER_SEC);
 }
 
 template <>
-int64_t DatePart::EpochOperator::Operation(interval_t input) {
+double DatePart::EpochOperator::Operation(interval_t input) {
 	int64_t interval_years = input.months / Interval::MONTHS_PER_YEAR;
 	int64_t interval_days;
 	interval_days = Interval::DAYS_PER_YEAR * interval_years;
@@ -897,20 +1033,29 @@ int64_t DatePart::EpochOperator::Operation(interval_t input) {
 	interval_epoch = interval_days * Interval::SECS_PER_DAY;
 	// we add 0.25 days per year to sort of account for leap days
 	interval_epoch += interval_years * (Interval::SECS_PER_DAY / 4);
-	interval_epoch += input.micros / Interval::MICROS_PER_SEC;
-	return interval_epoch;
+	return interval_epoch + input.micros / double(Interval::MICROS_PER_SEC);
 }
 
+//	TODO: We can't propagate interval statistics because we can't easily compare interval_t for order.
 template <>
-int64_t DatePart::EpochOperator::Operation(dtime_t input) {
-	return input.micros / Interval::MICROS_PER_SEC;
+unique_ptr<BaseStatistics> DatePart::EpochOperator::PropagateStatistics<interval_t>(ClientContext &context,
+                                                                                    FunctionStatisticsInput &input) {
+	return nullptr;
+}
+
+template <>
+double DatePart::EpochOperator::Operation(dtime_t input) {
+	return input.micros / double(Interval::MICROS_PER_SEC);
 }
 
 template <>
 unique_ptr<BaseStatistics> DatePart::EpochOperator::PropagateStatistics<dtime_t>(ClientContext &context,
                                                                                  FunctionStatisticsInput &input) {
-	// time seconds range over a single day
-	return PropagateSimpleDatePartStatistics<0, 86400>(input.child_stats);
+	auto result = NumericStats::CreateEmpty(LogicalType::DOUBLE);
+	result.CopyValidity(input.child_stats[0]);
+	NumericStats::SetMin(result, Value::DOUBLE(0));
+	NumericStats::SetMax(result, Value::DOUBLE(Interval::SECS_PER_DAY));
+	return result.ToUnique();
 }
 
 template <>
@@ -944,118 +1089,163 @@ int64_t DatePart::TimezoneOperator::Operation(dtime_t input) {
 }
 
 template <>
-void DatePart::StructOperator::Operation(int64_t **part_values, const dtime_t &input, const idx_t idx,
-                                         const part_mask_t mask) {
+double DatePart::JulianDayOperator::Operation(date_t input) {
+	return Date::ExtractJulianDay(input);
+}
+
+template <>
+double DatePart::JulianDayOperator::Operation(interval_t input) {
+	throw NotImplementedException("interval units \"julian\" not recognized");
+}
+
+template <>
+double DatePart::JulianDayOperator::Operation(dtime_t input) {
+	throw NotImplementedException("\"time\" units \"julian\" not recognized");
+}
+
+template <>
+void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &double_values, const dtime_t &input,
+                                         const idx_t idx, const part_mask_t mask) {
 	int64_t *part_data;
 	if (mask & TIME) {
 		const auto micros = MicrosecondsOperator::Operation<dtime_t, int64_t>(input);
-		if (HasPartValue(part_values, DatePartSpecifier::MICROSECONDS, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MICROSECONDS);
+		if (part_data) {
 			part_data[idx] = micros;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::MILLISECONDS, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MILLISECONDS);
+		if (part_data) {
 			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::SECOND, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::SECOND);
+		if (part_data) {
 			part_data[idx] = micros / Interval::MICROS_PER_SEC;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::MINUTE, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MINUTE);
+		if (part_data) {
 			part_data[idx] = MinutesOperator::Operation<dtime_t, int64_t>(input);
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::HOUR, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::HOUR);
+		if (part_data) {
 			part_data[idx] = HoursOperator::Operation<dtime_t, int64_t>(input);
 		}
 	}
 
 	if (mask & EPOCH) {
-		if (HasPartValue(part_values, DatePartSpecifier::EPOCH, part_data)) {
-			part_data[idx] = EpochOperator::Operation<dtime_t, int64_t>(input);
+		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
+		if (part_data) {
+			part_data[idx] = EpochOperator::Operation<dtime_t, double>(input);
+			;
 		}
 	}
 
 	if (mask & ZONE) {
-		if (HasPartValue(part_values, DatePartSpecifier::TIMEZONE, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE);
+		if (part_data) {
 			part_data[idx] = 0;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::TIMEZONE_HOUR, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE_HOUR);
+		if (part_data) {
 			part_data[idx] = 0;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::TIMEZONE_MINUTE, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE_MINUTE);
+		if (part_data) {
 			part_data[idx] = 0;
 		}
 	}
 }
 
 template <>
-void DatePart::StructOperator::Operation(int64_t **part_values, const timestamp_t &input, const idx_t idx,
-                                         const part_mask_t mask) {
+void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &double_values, const timestamp_t &input,
+                                         const idx_t idx, const part_mask_t mask) {
 	date_t d;
 	dtime_t t;
 	Timestamp::Convert(input, d, t);
 
 	// Both define epoch, and the correct value is the sum.
 	// So mask it out and compute it separately.
-	Operation(part_values, d, idx, mask & ~EPOCH);
-	Operation(part_values, t, idx, mask & ~EPOCH);
+	Operation(bigint_values, double_values, d, idx, mask & ~EPOCH);
+	Operation(bigint_values, double_values, t, idx, mask & ~EPOCH);
 
 	if (mask & EPOCH) {
-		int64_t *part_data;
-		if (HasPartValue(part_values, DatePartSpecifier::EPOCH, part_data)) {
-			part_data[idx] = EpochOperator::Operation<timestamp_t, int64_t>(input);
+		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
+		if (part_data) {
+			part_data[idx] = EpochOperator::Operation<timestamp_t, double>(input);
+		}
+	}
+
+	if (mask & JD) {
+		auto part_data = HasPartValue(double_values, DatePartSpecifier::JULIAN_DAY);
+		if (part_data) {
+			part_data[idx] = JulianDayOperator::Operation<timestamp_t, double>(input);
 		}
 	}
 }
 
 template <>
-void DatePart::StructOperator::Operation(int64_t **part_values, const interval_t &input, const idx_t idx,
-                                         const part_mask_t mask) {
+void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &double_values, const interval_t &input,
+                                         const idx_t idx, const part_mask_t mask) {
 	int64_t *part_data;
 	if (mask & YMD) {
 		const auto mm = input.months % Interval::MONTHS_PER_YEAR;
-		if (HasPartValue(part_values, DatePartSpecifier::YEAR, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::YEAR);
+		if (part_data) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_YEAR;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::MONTH, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MONTH);
+		if (part_data) {
 			part_data[idx] = mm;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::DAY, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::DAY);
+		if (part_data) {
 			part_data[idx] = input.days;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::DECADE, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::DECADE);
+		if (part_data) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_DECADE;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::CENTURY, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::CENTURY);
+		if (part_data) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_CENTURY;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::MILLENNIUM, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MILLENNIUM);
+		if (part_data) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_MILLENIUM;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::QUARTER, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::QUARTER);
+		if (part_data) {
 			part_data[idx] = mm / Interval::MONTHS_PER_QUARTER + 1;
 		}
 	}
 
 	if (mask & TIME) {
 		const auto micros = MicrosecondsOperator::Operation<interval_t, int64_t>(input);
-		if (HasPartValue(part_values, DatePartSpecifier::MICROSECONDS, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MICROSECONDS);
+		if (part_data) {
 			part_data[idx] = micros;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::MILLISECONDS, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MILLISECONDS);
+		if (part_data) {
 			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::SECOND, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::SECOND);
+		if (part_data) {
 			part_data[idx] = micros / Interval::MICROS_PER_SEC;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::MINUTE, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MINUTE);
+		if (part_data) {
 			part_data[idx] = MinutesOperator::Operation<interval_t, int64_t>(input);
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::HOUR, part_data)) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::HOUR);
+		if (part_data) {
 			part_data[idx] = HoursOperator::Operation<interval_t, int64_t>(input);
 		}
 	}
 
 	if (mask & EPOCH) {
-		if (HasPartValue(part_values, DatePartSpecifier::EPOCH, part_data)) {
-			part_data[idx] = EpochOperator::Operation<interval_t, int64_t>(input);
+		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
+		if (part_data) {
+			part_data[idx] = EpochOperator::Operation<interval_t, double>(input);
 		}
 	}
 }
@@ -1089,8 +1279,6 @@ static int64_t ExtractElement(DatePartSpecifier type, T element) {
 		return DatePart::ISOYearOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::YEARWEEK:
 		return DatePart::YearWeekOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::EPOCH:
-		return DatePart::EpochOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::MICROSECONDS:
 		return DatePart::MicrosecondsOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::MILLISECONDS:
@@ -1129,6 +1317,68 @@ static void DatePartFunction(DataChunk &args, ExpressionState &state, Vector &re
 	    });
 }
 
+static unique_ptr<FunctionData> DatePartBind(ClientContext &context, ScalarFunction &bound_function,
+                                             vector<unique_ptr<Expression>> &arguments) {
+	//	If we are only looking for Julian Days for timestamps,
+	//	then return doubles.
+	if (arguments[0]->HasParameter() || !arguments[0]->IsFoldable()) {
+		return nullptr;
+	}
+
+	Value part_value = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
+	const auto part_name = part_value.ToString();
+	switch (GetDatePartSpecifier(part_name)) {
+	case DatePartSpecifier::JULIAN_DAY:
+		arguments.erase(arguments.begin());
+		bound_function.arguments.erase(bound_function.arguments.begin());
+		bound_function.name = "julian";
+		bound_function.return_type = LogicalType::DOUBLE;
+		switch (arguments[0]->return_type.id()) {
+		case LogicalType::TIMESTAMP:
+			bound_function.function = DatePart::UnaryFunction<timestamp_t, double, DatePart::JulianDayOperator>;
+			bound_function.statistics = DatePart::JulianDayOperator::template PropagateStatistics<timestamp_t>;
+			break;
+		case LogicalType::DATE:
+			bound_function.function = DatePart::UnaryFunction<date_t, double, DatePart::JulianDayOperator>;
+			bound_function.statistics = DatePart::JulianDayOperator::template PropagateStatistics<date_t>;
+			break;
+		default:
+			throw BinderException("%s can only take DATE or TIMESTAMP arguments", bound_function.name);
+		}
+		break;
+	case DatePartSpecifier::EPOCH:
+		arguments.erase(arguments.begin());
+		bound_function.arguments.erase(bound_function.arguments.begin());
+		bound_function.name = "epoch";
+		bound_function.return_type = LogicalType::DOUBLE;
+		switch (arguments[0]->return_type.id()) {
+		case LogicalType::TIMESTAMP:
+			bound_function.function = DatePart::UnaryFunction<timestamp_t, double, DatePart::EpochOperator>;
+			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<timestamp_t>;
+			break;
+		case LogicalType::DATE:
+			bound_function.function = DatePart::UnaryFunction<date_t, double, DatePart::EpochOperator>;
+			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<date_t>;
+			break;
+		case LogicalType::INTERVAL:
+			bound_function.function = DatePart::UnaryFunction<interval_t, double, DatePart::EpochOperator>;
+			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<interval_t>;
+			break;
+		case LogicalType::TIME:
+			bound_function.function = DatePart::UnaryFunction<dtime_t, double, DatePart::EpochOperator>;
+			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<dtime_t>;
+			break;
+		default:
+			throw BinderException("%s can only take temporal arguments", bound_function.name);
+		}
+		break;
+	default:
+		break;
+	}
+
+	return nullptr;
+}
+
 ScalarFunctionSet GetGenericDatePartFunction(scalar_function_t date_func, scalar_function_t ts_func,
                                              scalar_function_t interval_func, function_statistics_t date_stats,
                                              function_statistics_t ts_stats) {
@@ -1149,26 +1399,26 @@ static ScalarFunctionSet GetDatePartFunction() {
 	    OP::template PropagateStatistics<timestamp_t>);
 }
 
-ScalarFunctionSet GetGenericTimePartFunction(scalar_function_t date_func, scalar_function_t ts_func,
-                                             scalar_function_t interval_func, scalar_function_t time_func,
-                                             function_statistics_t date_stats, function_statistics_t ts_stats,
-                                             function_statistics_t time_stats) {
+ScalarFunctionSet GetGenericTimePartFunction(const LogicalType &result_type, scalar_function_t date_func,
+                                             scalar_function_t ts_func, scalar_function_t interval_func,
+                                             scalar_function_t time_func, function_statistics_t date_stats,
+                                             function_statistics_t ts_stats, function_statistics_t time_stats) {
 	ScalarFunctionSet operator_set;
 	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, std::move(date_func), nullptr, nullptr, date_stats));
+	    ScalarFunction({LogicalType::DATE}, result_type, std::move(date_func), nullptr, nullptr, date_stats));
 	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, std::move(ts_func), nullptr, nullptr, ts_stats));
-	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, std::move(interval_func)));
+	    ScalarFunction({LogicalType::TIMESTAMP}, result_type, std::move(ts_func), nullptr, nullptr, ts_stats));
+	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, result_type, std::move(interval_func)));
 	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIME}, LogicalType::BIGINT, std::move(time_func), nullptr, nullptr, time_stats));
+	    ScalarFunction({LogicalType::TIME}, result_type, std::move(time_func), nullptr, nullptr, time_stats));
 	return operator_set;
 }
 
-template <class OP>
-static ScalarFunctionSet GetTimePartFunction() {
+template <class OP, class TR = int64_t>
+static ScalarFunctionSet GetTimePartFunction(const LogicalType &result_type = LogicalType::BIGINT) {
 	return GetGenericTimePartFunction(
-	    DatePart::UnaryFunction<date_t, int64_t, OP>, DatePart::UnaryFunction<timestamp_t, int64_t, OP>,
-	    ScalarFunction::UnaryFunction<interval_t, int64_t, OP>, ScalarFunction::UnaryFunction<dtime_t, int64_t, OP>,
+	    result_type, DatePart::UnaryFunction<date_t, TR, OP>, DatePart::UnaryFunction<timestamp_t, TR, OP>,
+	    ScalarFunction::UnaryFunction<interval_t, TR, OP>, ScalarFunction::UnaryFunction<dtime_t, TR, OP>,
 	    OP::template PropagateStatistics<date_t>, OP::template PropagateStatistics<timestamp_t>,
 	    OP::template PropagateStatistics<dtime_t>);
 }
@@ -1250,7 +1500,8 @@ struct StructDatePart {
 				}
 				name_collision_set.insert(part_name);
 				part_codes.emplace_back(part_code);
-				struct_children.emplace_back(make_pair(part_name, LogicalType::BIGINT));
+				const auto part_type = IsBigintDatepart(part_code) ? LogicalType::BIGINT : LogicalType::DOUBLE;
+				struct_children.emplace_back(make_pair(part_name, part_type));
 			}
 		} else {
 			throw BinderException("%s can only take constant lists of part names", bound_function.name);
@@ -1269,14 +1520,19 @@ struct StructDatePart {
 
 		const auto count = args.size();
 		Vector &input = args.data[0];
-		vector<int64_t *> part_values(int(DatePartSpecifier::TIMEZONE_MINUTE) + 1, nullptr);
+
+		//	Type counts
+		const auto BIGINT_COUNT = size_t(DatePartSpecifier::BEGIN_DOUBLE) - size_t(DatePartSpecifier::BEGIN_BIGINT);
+		const auto DOUBLE_COUNT = size_t(DatePartSpecifier::BEGIN_INVALID) - size_t(DatePartSpecifier::BEGIN_DOUBLE);
+		DatePart::StructOperator::bigint_vec bigint_values(BIGINT_COUNT, nullptr);
+		DatePart::StructOperator::double_vec double_values(DOUBLE_COUNT, nullptr);
 		const auto part_mask = DatePart::StructOperator::GetMask(info.part_codes);
 
 		auto &child_entries = StructVector::GetEntries(result);
 
 		// The first computer of a part "owns" it
 		// and other requestors just reference the owner
-		vector<size_t> owners(int(DatePartSpecifier::TIMEZONE_MINUTE) + 1, child_entries.size());
+		vector<size_t> owners(int(DatePartSpecifier::JULIAN_DAY) + 1, child_entries.size());
 		for (size_t col = 0; col < child_entries.size(); ++col) {
 			const auto part_index = size_t(info.part_codes[col]);
 			if (owners[part_index] == child_entries.size()) {
@@ -1296,12 +1552,18 @@ struct StructDatePart {
 					ConstantVector::SetNull(*child_entry, false);
 					const auto part_index = size_t(info.part_codes[col]);
 					if (owners[part_index] == col) {
-						part_values[part_index] = ConstantVector::GetData<int64_t>(*child_entry);
+						if (IsBigintDatepart(info.part_codes[col])) {
+							bigint_values[part_index - size_t(DatePartSpecifier::BEGIN_BIGINT)] =
+							    ConstantVector::GetData<int64_t>(*child_entry);
+						} else {
+							double_values[part_index - size_t(DatePartSpecifier::BEGIN_DOUBLE)] =
+							    ConstantVector::GetData<double>(*child_entry);
+						}
 					}
 				}
 				auto tdata = ConstantVector::GetData<INPUT_TYPE>(input);
 				if (Value::IsFinite(tdata[0])) {
-					DatePart::StructOperator::Operation(part_values.data(), tdata[0], 0, part_mask);
+					DatePart::StructOperator::Operation(bigint_values, double_values, tdata[0], 0, part_mask);
 				} else {
 					for (auto &child_entry : child_entries) {
 						ConstantVector::SetNull(*child_entry, true);
@@ -1334,7 +1596,13 @@ struct StructDatePart {
 				// Pre-multiplex
 				const auto part_index = size_t(info.part_codes[col]);
 				if (owners[part_index] == col) {
-					part_values[part_index] = FlatVector::GetData<int64_t>(*child_entry);
+					if (IsBigintDatepart(info.part_codes[col])) {
+						bigint_values[part_index - size_t(DatePartSpecifier::BEGIN_BIGINT)] =
+						    FlatVector::GetData<int64_t>(*child_entry);
+					} else {
+						double_values[part_index - size_t(DatePartSpecifier::BEGIN_DOUBLE)] =
+						    FlatVector::GetData<double>(*child_entry);
+					}
 				}
 			}
 
@@ -1342,7 +1610,7 @@ struct StructDatePart {
 				const auto idx = rdata.sel->get_index(i);
 				if (arg_valid.RowIsValid(idx)) {
 					if (Value::IsFinite(tdata[idx])) {
-						DatePart::StructOperator::Operation(part_values.data(), tdata[idx], i, part_mask);
+						DatePart::StructOperator::Operation(bigint_values, double_values, tdata[idx], i, part_mask);
 					} else {
 						for (auto &child_entry : child_entries) {
 							FlatVector::Validity(*child_entry).SetInvalid(i);
@@ -1369,18 +1637,17 @@ struct StructDatePart {
 		result.Verify(count);
 	}
 
-	static void SerializeFunction(FieldWriter &writer, const FunctionData *bind_data_p,
+	static void SerializeFunction(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
 	                              const ScalarFunction &function) {
 		D_ASSERT(bind_data_p);
 		auto &info = bind_data_p->Cast<BindData>();
-		writer.WriteSerializable(info.stype);
-		writer.WriteList<DatePartSpecifier>(info.part_codes);
+		serializer.WriteProperty(100, "stype", info.stype);
+		serializer.WriteProperty(101, "part_codes", info.part_codes);
 	}
 
-	static unique_ptr<FunctionData> DeserializeFunction(PlanDeserializationState &state, FieldReader &reader,
-	                                                    ScalarFunction &bound_function) {
-		auto stype = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-		auto part_codes = reader.ReadRequiredList<DatePartSpecifier>();
+	static unique_ptr<FunctionData> DeserializeFunction(Deserializer &deserializer, ScalarFunction &bound_function) {
+		auto stype = deserializer.ReadProperty<LogicalType>(100, "stype");
+		auto part_codes = deserializer.ReadProperty<vector<DatePartSpecifier>>(101, "part_codes");
 		return make_uniq<BindData>(std::move(stype), std::move(part_codes));
 	}
 
@@ -1463,7 +1730,48 @@ ScalarFunctionSet TimezoneMinuteFun::GetFunctions() {
 }
 
 ScalarFunctionSet EpochFun::GetFunctions() {
-	return GetTimePartFunction<DatePart::EpochOperator>();
+	return GetTimePartFunction<DatePart::EpochOperator, double>(LogicalType::DOUBLE);
+}
+
+ScalarFunctionSet EpochNsFun::GetFunctions() {
+	using OP = DatePart::EpochNanosecondsOperator;
+	auto operator_set = GetTimePartFunction<OP>();
+
+	//	TIMESTAMP WITH TIME ZONE has the same representation as TIMESTAMP so no need to defer to ICU
+	auto tstz_func = DatePart::UnaryFunction<timestamp_t, int64_t, OP>;
+	auto tstz_stats = OP::template PropagateStatistics<timestamp_t>;
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
+	return operator_set;
+}
+
+ScalarFunctionSet EpochUsFun::GetFunctions() {
+	using OP = DatePart::EpochMicrosecondsOperator;
+	auto operator_set = GetTimePartFunction<OP>();
+
+	//	TIMESTAMP WITH TIME ZONE has the same representation as TIMESTAMP so no need to defer to ICU
+	auto tstz_func = DatePart::UnaryFunction<timestamp_t, int64_t, OP>;
+	auto tstz_stats = OP::template PropagateStatistics<timestamp_t>;
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
+	return operator_set;
+}
+
+ScalarFunctionSet EpochMsFun::GetFunctions() {
+	using OP = DatePart::EpochMillisOperator;
+	auto operator_set = GetTimePartFunction<OP>();
+
+	//	TIMESTAMP WITH TIME ZONE has the same representation as TIMESTAMP so no need to defer to ICU
+	auto tstz_func = DatePart::UnaryFunction<timestamp_t, int64_t, OP>;
+	auto tstz_stats = OP::template PropagateStatistics<timestamp_t>;
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
+
+	//	Legacy inverse BIGINT => TIMESTAMP
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, DatePart::EpochMillisOperator::Inverse));
+
+	return operator_set;
 }
 
 ScalarFunctionSet MicrosecondsFun::GetFunctions() {
@@ -1529,16 +1837,32 @@ ScalarFunctionSet DayNameFun::GetFunctions() {
 	return dayname;
 }
 
+ScalarFunctionSet JulianDayFun::GetFunctions() {
+	using OP = DatePart::JulianDayOperator;
+
+	ScalarFunctionSet operator_set;
+	auto date_func = DatePart::UnaryFunction<date_t, double, OP>;
+	auto date_stats = OP::template PropagateStatistics<date_t>;
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::DATE}, LogicalType::DOUBLE, date_func, nullptr, nullptr, date_stats));
+	auto ts_func = DatePart::UnaryFunction<timestamp_t, double, OP>;
+	auto ts_stats = OP::template PropagateStatistics<timestamp_t>;
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::DOUBLE, ts_func, nullptr, nullptr, ts_stats));
+
+	return operator_set;
+}
+
 ScalarFunctionSet DatePartFun::GetFunctions() {
 	ScalarFunctionSet date_part;
-	date_part.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::BIGINT, DatePartFunction<date_t>));
+	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::BIGINT,
+	                                     DatePartFunction<date_t>, DatePartBind));
 	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::BIGINT,
-	                                     DatePartFunction<timestamp_t>));
-	date_part.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME}, LogicalType::BIGINT, DatePartFunction<dtime_t>));
+	                                     DatePartFunction<timestamp_t>, DatePartBind));
+	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME}, LogicalType::BIGINT,
+	                                     DatePartFunction<dtime_t>, DatePartBind));
 	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::BIGINT,
-	                                     DatePartFunction<interval_t>));
+	                                     DatePartFunction<interval_t>, DatePartBind));
 
 	// struct variants
 	date_part.AddFunction(StructDatePart::GetFunction<date_t>(LogicalType::DATE));