duckdb 0.8.2-dev3092.0 → 0.8.2-dev3190.0

package/package.json

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

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

@@ -14,7 +14,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) {
@@ -129,7 +130,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;
@@ -178,7 +198,16 @@ 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::JULIAN_DAY:
+			return ExtractJulianDay;
+		default:
+			throw Exception("Unsupported ICU DOUBLE extractor");
 		}
 	}
 
@@ -208,7 +237,7 @@ struct ICUDatePart : public ICUDateFunc {
 	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];
 	}
@@ -282,7 +311,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);
@@ -291,11 +320,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 = func_expr.bind_info->Cast<BIND_TYPE>();
+		auto &info = func_expr.bind_info->Cast<BindStructData>();
 		CalendarPtr calendar_ptr(info.calendar->clone());
 		auto calendar = calendar_ptr.get();
 
@@ -318,9 +373,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);
 					}
@@ -350,9 +411,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);
 						}
@@ -376,19 +443,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();
@@ -399,7 +501,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) {
@@ -407,7 +511,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);
 				}
@@ -417,8 +525,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);
@@ -426,7 +540,7 @@ 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,
@@ -440,15 +554,18 @@ struct ICUDatePart : public ICUDateFunc {
 	}
 
 	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) {
+	template <typename RESULT_TYPE = int64_t>
+	static void AddUnaryPartCodeFunctions(const string &name, ClientContext &context,
+	                                      const LogicalType &result_type = LogicalType::BIGINT) {
 		auto &catalog = Catalog::GetSystemCatalog(context);
 		ScalarFunctionSet set(name);
-		set.AddFunction(GetUnaryPartCodeFunction<timestamp_t, int64_t>(LogicalType::TIMESTAMP_TZ));
+		set.AddFunction(GetUnaryPartCodeFunction<timestamp_t, RESULT_TYPE>(LogicalType::TIMESTAMP_TZ, result_type));
 		CreateScalarFunctionInfo func_info(set);
 		catalog.AddFunction(context, func_info);
 	}
@@ -456,7 +573,7 @@ struct ICUDatePart : public ICUDateFunc {
 	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>
@@ -561,6 +678,8 @@ void RegisterICUDatePartFunctions(ClientContext &context) {
 	ICUDatePart::AddUnaryPartCodeFunctions("timezone_hour", context);
 	ICUDatePart::AddUnaryPartCodeFunctions("timezone_minute", context);
 
+	ICUDatePart::AddUnaryPartCodeFunctions<double>("julian", context, LogicalType::DOUBLE);
+
 	//  register combinations
 	ICUDatePart::AddUnaryPartCodeFunctions("yearweek", context); //  Note this is ISO year and week
 

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

@@ -171,6 +171,7 @@ ICUDateFunc::part_sub_t ICUDateFunc::SubtractFactory(DatePartSpecifier type) {
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
 	case DatePartSpecifier::DOY:
+	case DatePartSpecifier::JULIAN_DAY:
 		return ICUCalendarSub::SubtractDay;
 	case DatePartSpecifier::HOUR:
 		return ICUCalendarSub::SubtractHour;

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

@@ -175,6 +175,7 @@ ICUDateFunc::part_trunc_t ICUDateFunc::TruncationFactory(DatePartSpecifier type)
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
 	case DatePartSpecifier::DOY:
+	case DatePartSpecifier::JULIAN_DAY:
 		return ICUDateTrunc::TruncDay;
 	case DatePartSpecifier::HOUR:
 		return ICUDateTrunc::TruncHour;

package/src/duckdb/src/common/enum_util.cpp

@@ -1154,6 +1154,8 @@ const char* EnumUtil::ToChars<DatePartSpecifier>(DatePartSpecifier value) {
 		return "TIMEZONE_HOUR";
 	case DatePartSpecifier::TIMEZONE_MINUTE:
 		return "TIMEZONE_MINUTE";
+	case DatePartSpecifier::JULIAN_DAY:
+		return "JULIAN_DAY";
 	default:
 		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
 	}
@@ -1230,6 +1232,9 @@ DatePartSpecifier EnumUtil::FromString<DatePartSpecifier>(const char *value) {
 	if (StringUtil::Equals(value, "TIMEZONE_MINUTE")) {
 		return DatePartSpecifier::TIMEZONE_MINUTE;
 	}
+	if (StringUtil::Equals(value, "JULIAN_DAY")) {
+		return DatePartSpecifier::JULIAN_DAY;
+	}
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 

package/src/duckdb/src/common/enums/date_part_specifier.cpp

@@ -65,6 +65,8 @@ bool TryGetDatePartSpecifier(const string &specifier_p, DatePartSpecifier &resul
 		result = DatePartSpecifier::TIMEZONE_HOUR;
 	} else if (specifier == "timezone_minute") {
 		result = DatePartSpecifier::TIMEZONE_MINUTE;
+	} else if (specifier == "julian" || specifier == "jd") {
+		result = DatePartSpecifier::JULIAN_DAY;
 	} else {
 		return false;
 	}

package/src/duckdb/src/common/types/date.cpp

@@ -490,6 +490,12 @@ int32_t Date::ExtractDayOfTheYear(date_t date) {
 	return date.days - Date::CUMULATIVE_YEAR_DAYS[year_offset] + 1;
 }
 
+int64_t Date::ExtractJulianDay(date_t date) {
+	// Julian Day 0 is (-4713, 11, 24) in the proleptic Gregorian calendar.
+	static const auto JULIAN_EPOCH = -2440588;
+	return date.days - JULIAN_EPOCH;
+}
+
 int32_t Date::ExtractISODayOfTheWeek(date_t date) {
 	// date of 0 is 1970-01-01, which was a Thursday (4)
 	// -7 = 4

package/src/duckdb/src/common/types/timestamp.cpp

@@ -341,4 +341,11 @@ int64_t Timestamp::GetEpochNanoSeconds(timestamp_t timestamp) {
 	return result;
 }
 
+double Timestamp::GetJulianDay(timestamp_t timestamp) {
+	double result = Timestamp::GetTime(timestamp).micros;
+	result /= Interval::MICROS_PER_DAY;
+	result += Date::ExtractJulianDay(Timestamp::GetDate(timestamp));
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/src/core_functions/function_list.cpp

@@ -182,6 +182,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION(JaccardFun),
 	DUCKDB_SCALAR_FUNCTION(JaroSimilarityFun),
 	DUCKDB_SCALAR_FUNCTION(JaroWinklerSimilarityFun),
+	DUCKDB_SCALAR_FUNCTION_SET(JulianDayFun),
 	DUCKDB_AGGREGATE_FUNCTION(KahanSumFun),
 	DUCKDB_AGGREGATE_FUNCTION(KurtosisFun),
 	DUCKDB_SCALAR_FUNCTION_SET(LastDayFun),

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

@@ -304,6 +304,7 @@ static int64_t DifferenceDates(DatePartSpecifier type, TA startdate, TB enddate)
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
 	case DatePartSpecifier::DOY:
+	case DatePartSpecifier::JULIAN_DAY:
 		return DateDiff::DayOperator::template Operation<TA, TB, TR>(startdate, enddate);
 	case DatePartSpecifier::DECADE:
 		return DateDiff::DecadeOperator::template Operation<TA, TB, TR>(startdate, enddate);
@@ -359,6 +360,7 @@ static void DateDiffBinaryExecutor(DatePartSpecifier type, Vector &left, Vector
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
 	case DatePartSpecifier::DOY:
+	case DatePartSpecifier::JULIAN_DAY:
 		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::DayOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::DECADE:

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();
 	}
@@ -499,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;
@@ -514,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) {
@@ -546,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:
@@ -564,63 +582,73 @@ struct DatePart {
 		}
 
 		template <typename P>
-		static inline P HasPartValue(P *part_values, DatePartSpecifier part) {
-			return part_values[int(part)];
+		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);
-				part_data = HasPartValue(part_values, DatePartSpecifier::YEAR);
-				if (part_data) {
-					part_data[idx] = yyyy;
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::YEAR);
+				if (bigint_data) {
+					bigint_data[idx] = yyyy;
 				}
-				part_data = HasPartValue(part_values, DatePartSpecifier::MONTH);
-				if (part_data) {
-					part_data[idx] = mm;
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::MONTH);
+				if (bigint_data) {
+					bigint_data[idx] = mm;
 				}
-				part_data = HasPartValue(part_values, DatePartSpecifier::DAY);
-				if (part_data) {
-					part_data[idx] = dd;
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::DAY);
+				if (bigint_data) {
+					bigint_data[idx] = dd;
 				}
-				part_data = HasPartValue(part_values, DatePartSpecifier::DECADE);
-				if (part_data) {
-					part_data[idx] = DecadeOperator::DecadeFromYear(yyyy);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::DECADE);
+				if (bigint_data) {
+					bigint_data[idx] = DecadeOperator::DecadeFromYear(yyyy);
 				}
-				part_data = HasPartValue(part_values, DatePartSpecifier::CENTURY);
-				if (part_data) {
-					part_data[idx] = CenturyOperator::CenturyFromYear(yyyy);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::CENTURY);
+				if (bigint_data) {
+					bigint_data[idx] = CenturyOperator::CenturyFromYear(yyyy);
 				}
-				part_data = HasPartValue(part_values, DatePartSpecifier::MILLENNIUM);
-				if (part_data) {
-					part_data[idx] = MillenniumOperator::MillenniumFromYear(yyyy);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::MILLENNIUM);
+				if (bigint_data) {
+					bigint_data[idx] = MillenniumOperator::MillenniumFromYear(yyyy);
 				}
-				part_data = HasPartValue(part_values, DatePartSpecifier::QUARTER);
-				if (part_data) {
-					part_data[idx] = QuarterOperator::QuarterFromMonth(mm);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::QUARTER);
+				if (bigint_data) {
+					bigint_data[idx] = QuarterOperator::QuarterFromMonth(mm);
 				}
-				part_data = HasPartValue(part_values, DatePartSpecifier::ERA);
-				if (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);
-				part_data = HasPartValue(part_values, DatePartSpecifier::DOW);
-				if (part_data) {
-					part_data[idx] = DayOfWeekOperator::DayOfWeekFromISO(isodow);
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::DOW);
+				if (bigint_data) {
+					bigint_data[idx] = DayOfWeekOperator::DayOfWeekFromISO(isodow);
 				}
-				part_data = HasPartValue(part_values, DatePartSpecifier::ISODOW);
-				if (part_data) {
-					part_data[idx] = isodow;
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::ISODOW);
+				if (bigint_data) {
+					bigint_data[idx] = isodow;
 				}
 			}
 
@@ -629,30 +657,36 @@ struct DatePart {
 				int32_t ww = 0;
 				int32_t iyyy = 0;
 				Date::ExtractISOYearWeek(input, iyyy, ww);
-				part_data = HasPartValue(part_values, DatePartSpecifier::WEEK);
-				if (part_data) {
-					part_data[idx] = ww;
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::WEEK);
+				if (bigint_data) {
+					bigint_data[idx] = ww;
 				}
-				part_data = HasPartValue(part_values, DatePartSpecifier::ISOYEAR);
-				if (part_data) {
-					part_data[idx] = iyyy;
+				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::ISOYEAR);
+				if (bigint_data) {
+					bigint_data[idx] = iyyy;
 				}
-				part_data = HasPartValue(part_values, DatePartSpecifier::YEARWEEK);
-				if (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) {
-				part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH);
-				if (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) {
-				part_data = HasPartValue(part_values, DatePartSpecifier::DOY);
-				if (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);
 				}
 			}
 		}
@@ -1046,35 +1080,50 @@ 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);
-		part_data = HasPartValue(part_values, DatePartSpecifier::MICROSECONDS);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MICROSECONDS);
 		if (part_data) {
 			part_data[idx] = micros;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::MILLISECONDS);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MILLISECONDS);
 		if (part_data) {
 			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::SECOND);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::SECOND);
 		if (part_data) {
 			part_data[idx] = micros / Interval::MICROS_PER_SEC;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::MINUTE);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MINUTE);
 		if (part_data) {
 			part_data[idx] = MinutesOperator::Operation<dtime_t, int64_t>(input);
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::HOUR);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::HOUR);
 		if (part_data) {
 			part_data[idx] = HoursOperator::Operation<dtime_t, int64_t>(input);
 		}
 	}
 
 	if (mask & EPOCH) {
-		part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::EPOCH);
 		if (part_data) {
 			part_data[idx] = EpochOperator::Operation<dtime_t, int64_t>(input);
 			;
@@ -1082,15 +1131,15 @@ void DatePart::StructOperator::Operation(int64_t **part_values, const dtime_t &i
 	}
 
 	if (mask & ZONE) {
-		part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE);
 		if (part_data) {
 			part_data[idx] = 0;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE_HOUR);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE_HOUR);
 		if (part_data) {
 			part_data[idx] = 0;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE_MINUTE);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE_MINUTE);
 		if (part_data) {
 			part_data[idx] = 0;
 		}
@@ -1098,56 +1147,63 @@ void DatePart::StructOperator::Operation(int64_t **part_values, const dtime_t &i
 }
 
 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) {
-		auto part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH);
+		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;
-		part_data = HasPartValue(part_values, DatePartSpecifier::YEAR);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::YEAR);
 		if (part_data) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_YEAR;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::MONTH);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MONTH);
 		if (part_data) {
 			part_data[idx] = mm;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::DAY);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::DAY);
 		if (part_data) {
 			part_data[idx] = input.days;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::DECADE);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::DECADE);
 		if (part_data) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_DECADE;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::CENTURY);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::CENTURY);
 		if (part_data) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_CENTURY;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::MILLENNIUM);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MILLENNIUM);
 		if (part_data) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_MILLENIUM;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::QUARTER);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::QUARTER);
 		if (part_data) {
 			part_data[idx] = mm / Interval::MONTHS_PER_QUARTER + 1;
 		}
@@ -1155,30 +1211,30 @@ void DatePart::StructOperator::Operation(int64_t **part_values, const interval_t
 
 	if (mask & TIME) {
 		const auto micros = MicrosecondsOperator::Operation<interval_t, int64_t>(input);
-		part_data = HasPartValue(part_values, DatePartSpecifier::MICROSECONDS);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MICROSECONDS);
 		if (part_data) {
 			part_data[idx] = micros;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::MILLISECONDS);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MILLISECONDS);
 		if (part_data) {
 			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::SECOND);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::SECOND);
 		if (part_data) {
 			part_data[idx] = micros / Interval::MICROS_PER_SEC;
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::MINUTE);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MINUTE);
 		if (part_data) {
 			part_data[idx] = MinutesOperator::Operation<interval_t, int64_t>(input);
 		}
-		part_data = HasPartValue(part_values, DatePartSpecifier::HOUR);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::HOUR);
 		if (part_data) {
 			part_data[idx] = HoursOperator::Operation<interval_t, int64_t>(input);
 		}
 	}
 
 	if (mask & EPOCH) {
-		part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::EPOCH);
 		if (part_data) {
 			part_data[idx] = EpochOperator::Operation<interval_t, int64_t>(input);
 		}
@@ -1254,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) {
@@ -1332,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;
 
@@ -1375,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);
@@ -1394,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()) {
@@ -1421,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);
@@ -1459,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);
+					}
 				}
 			}
 
@@ -1467,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);
@@ -1695,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));

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

@@ -322,6 +322,7 @@ static int64_t SubtractDateParts(DatePartSpecifier type, TA startdate, TB enddat
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
 	case DatePartSpecifier::DOY:
+	case DatePartSpecifier::JULIAN_DAY:
 		return DateSub::DayOperator::template Operation<TA, TB, TR>(startdate, enddate);
 	case DatePartSpecifier::DECADE:
 		return DateSub::DecadeOperator::template Operation<TA, TB, TR>(startdate, enddate);
@@ -376,6 +377,7 @@ static void DateSubBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
 	case DatePartSpecifier::DOY:
+	case DatePartSpecifier::JULIAN_DAY:
 		DateSub::BinaryExecute<TA, TB, TR, DateSub::DayOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::DECADE:

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

@@ -485,6 +485,7 @@ static TR TruncateElement(DatePartSpecifier type, TA element) {
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
 	case DatePartSpecifier::DOY:
+	case DatePartSpecifier::JULIAN_DAY:
 		return DateTrunc::DayOperator::Operation<TA, TR>(element);
 	case DatePartSpecifier::HOUR:
 		return DateTrunc::HourOperator::Operation<TA, TR>(element);
@@ -541,6 +542,7 @@ static void DateTruncUnaryExecutor(DatePartSpecifier type, Vector &left, Vector
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
 	case DatePartSpecifier::DOY:
+	case DatePartSpecifier::JULIAN_DAY:
 		DateTrunc::UnaryExecute<TA, TR, DateTrunc::DayOperator>(left, result, count);
 		break;
 	case DatePartSpecifier::HOUR:
@@ -641,6 +643,7 @@ static function_statistics_t DateTruncStats(DatePartSpecifier type) {
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
 	case DatePartSpecifier::DOY:
+	case DatePartSpecifier::JULIAN_DAY:
 		return PropagateDateTruncStatistics<TA, TR, DateTrunc::DayOperator>;
 	case DatePartSpecifier::HOUR:
 		return PropagateDateTruncStatistics<TA, TR, DateTrunc::HourOperator>;
@@ -685,6 +688,7 @@ static unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunc
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
 	case DatePartSpecifier::DOY:
+	case DatePartSpecifier::JULIAN_DAY:
 		switch (bound_function.arguments[1].id()) {
 		case LogicalType::TIMESTAMP:
 			bound_function.function = DateTruncFunction<timestamp_t, date_t>;

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev3092"
+#define DUCKDB_VERSION "0.8.2-dev3190"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "1f17e1cec6"
+#define DUCKDB_SOURCE_ID "3196df79ce"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/enums/date_part_specifier.hpp

@@ -13,6 +13,7 @@
 namespace duckdb {
 
 enum class DatePartSpecifier : uint8_t {
+	//	BIGINT values
 	YEAR,
 	MONTH,
 	DAY,
@@ -35,9 +36,16 @@ enum class DatePartSpecifier : uint8_t {
 	ERA,
 	TIMEZONE,
 	TIMEZONE_HOUR,
-	TIMEZONE_MINUTE
+	TIMEZONE_MINUTE,
+
+	//	DOUBLE values
+	JULIAN_DAY
 };
 
+inline bool IsBigintDatepart(DatePartSpecifier part_code) {
+	return size_t(part_code) < size_t(DatePartSpecifier::JULIAN_DAY);
+}
+
 DUCKDB_API bool TryGetDatePartSpecifier(const string &specifier, DatePartSpecifier &result);
 DUCKDB_API DatePartSpecifier GetDatePartSpecifier(const string &specifier);
 

package/src/duckdb/src/include/duckdb/common/types/date.hpp

@@ -181,6 +181,8 @@ public:
 	DUCKDB_API static int32_t ExtractISODayOfTheWeek(date_t date);
 	//! Extract the day of the year
 	DUCKDB_API static int32_t ExtractDayOfTheYear(date_t date);
+	//! Extract the day of the year
+	DUCKDB_API static int64_t ExtractJulianDay(date_t date);
 	//! Extract the ISO week number
 	//! ISO weeks start on Monday and the first week of a year
 	//! contains January 4 of that year.

package/src/duckdb/src/include/duckdb/common/types/timestamp.hpp

@@ -151,6 +151,8 @@ public:
 	DUCKDB_API static int64_t GetEpochMicroSeconds(timestamp_t timestamp);
 	//! Convert a timestamp to epoch (in nanoseconds)
 	DUCKDB_API static int64_t GetEpochNanoSeconds(timestamp_t timestamp);
+	//! Convert a timestamp to a Julian Day
+	DUCKDB_API static double GetJulianDay(timestamp_t timestamp);
 
 	DUCKDB_API static bool TryParseUTCOffset(const char *str, idx_t &pos, idx_t len, int &hour_offset,
 	                                         int &minute_offset);

package/src/duckdb/src/include/duckdb/core_functions/scalar/date_functions.hpp

@@ -264,6 +264,15 @@ struct ISOYearFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
+struct JulianDayFun {
+	static constexpr const char *Name = "julian";
+	static constexpr const char *Parameters = "ts";
+	static constexpr const char *Description = "Extract the Julian Day number from a date or timestamp";
+	static constexpr const char *Example = "julian(timestamp '2006-01-01 12:00')";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
 struct LastDayFun {
 	static constexpr const char *Name = "last_day";
 	static constexpr const char *Parameters = "ts";

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

@@ -37,12 +37,23 @@ static void ComputeSHA256String(const std::string &to_hash, std::string *res) {
 }
 
 static void ComputeSHA256FileSegment(FileHandle *handle, const idx_t start, const idx_t end, std::string *res) {
-	const idx_t len = end - start;
-	string file_content;
-	file_content.resize(len);
-	handle->Read((void *)file_content.data(), len, start);
+	idx_t iter = start;
+	const idx_t segment_size = 1024 * 8;
 
-	ComputeSHA256String(file_content, res);
+	duckdb_mbedtls::MbedTlsWrapper::SHA256State state;
+
+	std::string to_hash;
+	while (iter < end) {
+		idx_t len = std::min(end - iter, segment_size);
+		to_hash.resize(len);
+		handle->Read((void *)to_hash.data(), len, iter);
+
+		state.AddString(to_hash);
+
+		iter += segment_size;
+	}
+
+	*res = state.Finalize();
 }
 #endif
 

package/src/duckdb/src/planner/expression/bound_cast_expression.cpp

@@ -142,12 +142,10 @@ bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const
 	}
 	if (source_type.id() == LogicalTypeId::VARCHAR) {
 		switch (target_type.id()) {
-		case LogicalTypeId::TIME:
 		case LogicalTypeId::TIMESTAMP:
 		case LogicalTypeId::TIMESTAMP_NS:
 		case LogicalTypeId::TIMESTAMP_MS:
 		case LogicalTypeId::TIMESTAMP_SEC:
-		case LogicalTypeId::TIME_TZ:
 		case LogicalTypeId::TIMESTAMP_TZ:
 			return true;
 		default:

package/src/duckdb/third_party/mbedtls/include/mbedtls_wrapper.hpp

@@ -19,5 +19,15 @@ public:
 	static void Hmac256(const char* key, size_t key_len, const char* message, size_t message_len, char* out);
 
 	static constexpr size_t SHA256_HASH_BYTES = 32;
+
+	class SHA256State {
+	public:
+		SHA256State();
+		~SHA256State();
+		void AddString(const std::string & str);
+		std::string Finalize();
+	private:
+		void *sha_context;
+	};
 };
 }

package/src/duckdb/third_party/mbedtls/mbedtls_wrapper.cpp

@@ -81,4 +81,34 @@ void MbedTlsWrapper::Hmac256(const char* key, size_t key_len, const char* messag
 		throw runtime_error("HMAC256 Error");
 	}
 	mbedtls_md_free(&hmac_ctx);
-}
+}
+
+MbedTlsWrapper::SHA256State::SHA256State() : sha_context(new mbedtls_sha256_context()) {
+	mbedtls_sha256_init((mbedtls_sha256_context*)sha_context);
+
+	if (mbedtls_sha256_starts((mbedtls_sha256_context*)sha_context, false)) {
+		throw std::runtime_error("SHA256 Error");
+	}
+}
+
+MbedTlsWrapper::SHA256State::~SHA256State() {
+	mbedtls_sha256_free((mbedtls_sha256_context*)sha_context);
+	delete (mbedtls_sha256_context*)sha_context;
+}
+
+void MbedTlsWrapper::SHA256State::AddString(const std::string & str) {
+	if (mbedtls_sha256_update((mbedtls_sha256_context*)sha_context, (unsigned char*)str.data(), str.size())) {
+		throw std::runtime_error("SHA256 Error");
+	}
+}
+
+std::string MbedTlsWrapper::SHA256State::Finalize() {
+	string hash;
+	hash.resize(MbedTlsWrapper::SHA256_HASH_BYTES);
+
+	if (mbedtls_sha256_finish((mbedtls_sha256_context*)sha_context, (unsigned char*)hash.data())) {
+		throw std::runtime_error("SHA256 Error");
+	}
+
+	return hash;
+}