duckdb 0.8.2-dev37.0 → 0.8.2-dev3949.0

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

@@ -37,6 +37,7 @@ DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType
 		case DatePartSpecifier::DOY:
 		case DatePartSpecifier::YEARWEEK:
 		case DatePartSpecifier::ERA:
+		case DatePartSpecifier::JULIAN_DAY:
 			return part;
 		default:
 			break;
@@ -97,8 +98,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 +116,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 +356,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) {
@@ -456,6 +501,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 +528,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 +561,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:
@@ -521,54 +582,73 @@ struct DatePart {
 		}
 
 		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) {
+			static const auto BEGIN_DOUBLE = size_t(DatePartSpecifier::JULIAN_DAY);
+			auto idx = size_t(part);
+			if (IsBigintDatepart(part)) {
+				return part_values[idx];
+			} else {
+				return part_values[idx - 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);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::EPOCH);
+				if (bigint_data) {
+					bigint_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);
@@ -944,117 +1080,162 @@ 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 = HasPartValue(bigint_values, DatePartSpecifier::EPOCH);
+		if (part_data) {
 			part_data[idx] = EpochOperator::Operation<dtime_t, int64_t>(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)) {
+		auto part_data = HasPartValue(bigint_values, DatePartSpecifier::EPOCH);
+		if (part_data) {
 			part_data[idx] = EpochOperator::Operation<timestamp_t, int64_t>(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 = HasPartValue(bigint_values, DatePartSpecifier::EPOCH);
+		if (part_data) {
 			part_data[idx] = EpochOperator::Operation<interval_t, int64_t>(input);
 		}
 	}
@@ -1129,6 +1310,45 @@ 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]);
+	if (part_value.IsNull()) {
+		return nullptr;
+	}
+	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;
+	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) {
@@ -1207,6 +1427,10 @@ struct DayNameOperator {
 struct StructDatePart {
 	using part_codes_t = vector<DatePartSpecifier>;
 
+	static const auto BEGIN_BIGINT = size_t(DatePartSpecifier::YEAR);
+	static const auto BEGIN_DOUBLE = size_t(DatePartSpecifier::JULIAN_DAY);
+	static const auto BEGIN_INVALID = size_t(DatePartSpecifier::JULIAN_DAY) + 1;
+
 	struct BindData : public VariableReturnBindData {
 		part_codes_t part_codes;
 
@@ -1250,7 +1474,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 +1494,15 @@ struct StructDatePart {
 
 		const auto count = args.size();
 		Vector &input = args.data[0];
-		vector<int64_t *> part_values(int(DatePartSpecifier::TIMEZONE_MINUTE) + 1, nullptr);
+		DatePart::StructOperator::bigint_vec bigint_values(size_t(BEGIN_DOUBLE), nullptr);
+		DatePart::StructOperator::double_vec double_values(BEGIN_INVALID - size_t(BEGIN_DOUBLE), 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 +1522,16 @@ 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 - BEGIN_BIGINT] = ConstantVector::GetData<int64_t>(*child_entry);
+						} else {
+							double_values[part_index - 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 +1564,11 @@ 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 - BEGIN_BIGINT] = FlatVector::GetData<int64_t>(*child_entry);
+					} else {
+						double_values[part_index - BEGIN_DOUBLE] = FlatVector::GetData<double>(*child_entry);
+					}
 				}
 			}
 
@@ -1342,7 +1576,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);
@@ -1466,6 +1700,47 @@ ScalarFunctionSet EpochFun::GetFunctions() {
 	return GetTimePartFunction<DatePart::EpochOperator>();
 }
 
+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() {
 	return GetTimePartFunction<DatePart::MicrosecondsOperator>();
 }
@@ -1529,16 +1804,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));