duckdb 1.3.4 → 1.4.0

package/src/duckdb/extension/core_functions/scalar/bit/bitstring.cpp

@@ -55,6 +55,8 @@ ScalarFunctionSet BitStringFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // get_bit
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct GetBitOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA input, TB n) {
@@ -66,6 +68,7 @@ struct GetBitOperator {
 	}
 };
 
+} // namespace
 ScalarFunction GetBitFun::GetFunction() {
 	ScalarFunction func({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::INTEGER,
 	                    ScalarFunction::BinaryFunction<string_t, int32_t, int32_t, GetBitOperator>);
@@ -104,6 +107,8 @@ ScalarFunction SetBitFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // bit_position
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct BitPositionOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA substring, TB input) {
@@ -114,6 +119,8 @@ struct BitPositionOperator {
 	}
 };
 
+} // namespace
+
 ScalarFunction BitPositionFun::GetFunction() {
 	return ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::INTEGER,
 	                      ScalarFunction::BinaryFunction<string_t, string_t, int32_t, BitPositionOperator>);

package/src/duckdb/extension/core_functions/scalar/blob/base64.cpp

@@ -3,6 +3,7 @@
 
 namespace duckdb {
 
+namespace {
 struct Base64EncodeOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
@@ -24,16 +25,18 @@ struct Base64DecodeOperator {
 	}
 };
 
-static void Base64EncodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void Base64EncodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	// decode is also a nop cast, but requires verification if the provided string is actually
 	UnaryExecutor::ExecuteString<string_t, string_t, Base64EncodeOperator>(args.data[0], result, args.size());
 }
 
-static void Base64DecodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void Base64DecodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	// decode is also a nop cast, but requires verification if the provided string is actually
 	UnaryExecutor::ExecuteString<string_t, string_t, Base64DecodeOperator>(args.data[0], result, args.size());
 }
 
+} // namespace
+
 ScalarFunction ToBase64Fun::GetFunction() {
 	return ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, Base64EncodeFunction);
 }

package/src/duckdb/extension/core_functions/scalar/blob/encode.cpp

@@ -4,7 +4,9 @@
 
 namespace duckdb {
 
-static void EncodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+namespace {
+
+void EncodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	// encode is essentially a nop cast from varchar to blob
 	// we only need to reinterpret the data using the blob type
 	result.Reinterpret(args.data[0]);
@@ -23,12 +25,14 @@ struct BlobDecodeOperator {
 	}
 };
 
-static void DecodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void DecodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	// decode is also a nop cast, but requires verification if the provided string is actually
 	UnaryExecutor::Execute<string_t, string_t, BlobDecodeOperator>(args.data[0], result, args.size());
 	StringVector::AddHeapReference(result, args.data[0]);
 }
 
+} // namespace
+
 ScalarFunction EncodeFun::GetFunction() {
 	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, EncodeFunction);
 }

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

@@ -14,6 +14,8 @@ namespace duckdb {
 
 // This function is an implementation of the "period-crossing" date difference function from T-SQL
 // https://docs.microsoft.com/en-us/sql/t-sql/functions/datediff-transact-sql?view=sql-server-ver15
+
+namespace {
 struct DateDiff {
 	template <class TA, class TB, class TR, class OP>
 	static inline void BinaryExecute(Vector &left, Vector &right, Vector &result, idx_t count) {
@@ -308,7 +310,7 @@ int64_t DateDiff::HoursOperator::Operation(dtime_t startdate, dtime_t enddate) {
 }
 
 template <typename TA, typename TB, typename TR>
-static int64_t DifferenceDates(DatePartSpecifier type, TA startdate, TB enddate) {
+int64_t DifferenceDates(DatePartSpecifier type, TA startdate, TB enddate) {
 	switch (type) {
 	case DatePartSpecifier::YEAR:
 		return DateDiff::YearOperator::template Operation<TA, TB, TR>(startdate, enddate);
@@ -362,7 +364,7 @@ struct DateDiffTernaryOperator {
 };
 
 template <typename TA, typename TB, typename TR>
-static void DateDiffBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right, Vector &result, idx_t count) {
+void DateDiffBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right, Vector &result, idx_t count) {
 	switch (type) {
 	case DatePartSpecifier::YEAR:
 		DateDiff::BinaryExecute<TA, TB, TR, DateDiff::YearOperator>(left, right, result, count);
@@ -418,7 +420,7 @@ static void DateDiffBinaryExecutor(DatePartSpecifier type, Vector &left, Vector
 }
 
 template <typename T>
-static void DateDiffFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void DateDiffFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 3);
 	auto &part_arg = args.data[0];
 	auto &start_arg = args.data[1];
@@ -440,6 +442,8 @@ static void DateDiffFunction(DataChunk &args, ExpressionState &state, Vector &re
 	}
 }
 
+} // namespace
+
 ScalarFunctionSet DateDiffFun::GetFunctions() {
 	ScalarFunctionSet date_diff("date_diff");
 	date_diff.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE, LogicalType::DATE},

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

@@ -5,18 +5,15 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/exception/conversion_exception.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/date_lookup_cache.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 
 namespace duckdb {
 
+namespace {
 DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType &type) {
 	const auto part = GetDatePartSpecifier(specifier);
 	switch (type.id()) {
@@ -47,6 +44,7 @@ DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType
 		}
 		break;
 	case LogicalType::TIME:
+	case LogicalType::TIME_NS:
 	case LogicalType::TIME_TZ:
 		switch (part) {
 		case DatePartSpecifier::MICROSECONDS:
@@ -91,7 +89,7 @@ DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType
 }
 
 template <int64_t MIN, int64_t MAX>
-static unique_ptr<BaseStatistics> PropagateSimpleDatePartStatistics(vector<BaseStatistics> &child_stats) {
+unique_ptr<BaseStatistics> PropagateSimpleDatePartStatistics(vector<BaseStatistics> &child_stats) {
 	// we can always propagate simple date part statistics
 	// since the min and max can never exceed these bounds
 	auto result = NumericStats::CreateEmpty(LogicalType::BIGINT);
@@ -769,7 +767,7 @@ struct DatePart {
 };
 
 template <class OP, class T>
-static void DatePartCachedFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void DatePartCachedFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<DateCacheLocalState<OP>>();
 	UnaryExecutor::ExecuteWithNulls<T, int64_t>(
 	    args.data[0], result, args.size(),
@@ -791,6 +789,11 @@ int64_t DatePart::YearOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"year\" not recognized");
 }
 
+template <>
+int64_t DatePart::YearOperator::Operation(dtime_ns_t input) {
+	return YearOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::YearOperator::Operation(dtime_tz_t input) {
 	return YearOperator::Operation<dtime_t, int64_t>(input.time());
@@ -811,6 +814,11 @@ int64_t DatePart::MonthOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"month\" not recognized");
 }
 
+template <>
+int64_t DatePart::MonthOperator::Operation(dtime_ns_t input) {
+	return MonthOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::MonthOperator::Operation(dtime_tz_t input) {
 	return MonthOperator::Operation<dtime_t, int64_t>(input.time());
@@ -831,6 +839,11 @@ int64_t DatePart::DayOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"day\" not recognized");
 }
 
+template <>
+int64_t DatePart::DayOperator::Operation(dtime_ns_t input) {
+	return DayOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::DayOperator::Operation(dtime_tz_t input) {
 	return DayOperator::Operation<dtime_t, int64_t>(input.time());
@@ -896,6 +909,11 @@ int64_t DatePart::QuarterOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"quarter\" not recognized");
 }
 
+template <>
+int64_t DatePart::QuarterOperator::Operation(dtime_ns_t input) {
+	return QuarterOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::QuarterOperator::Operation(dtime_tz_t input) {
 	return QuarterOperator::Operation<dtime_t, int64_t>(input.time());
@@ -916,6 +934,11 @@ int64_t DatePart::DayOfWeekOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"dow\" not recognized");
 }
 
+template <>
+int64_t DatePart::DayOfWeekOperator::Operation(dtime_ns_t input) {
+	return DayOfWeekOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::DayOfWeekOperator::Operation(dtime_tz_t input) {
 	return DayOfWeekOperator::Operation<dtime_t, int64_t>(input.time());
@@ -936,6 +959,11 @@ int64_t DatePart::ISODayOfWeekOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"isodow\" not recognized");
 }
 
+template <>
+int64_t DatePart::ISODayOfWeekOperator::Operation(dtime_ns_t input) {
+	return ISODayOfWeekOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::ISODayOfWeekOperator::Operation(dtime_tz_t input) {
 	return ISODayOfWeekOperator::Operation<dtime_t, int64_t>(input.time());
@@ -956,6 +984,11 @@ int64_t DatePart::DayOfYearOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"doy\" not recognized");
 }
 
+template <>
+int64_t DatePart::DayOfYearOperator::Operation(dtime_ns_t input) {
+	return DayOfYearOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::DayOfYearOperator::Operation(dtime_tz_t input) {
 	return DayOfYearOperator::Operation<dtime_t, int64_t>(input.time());
@@ -976,6 +1009,11 @@ int64_t DatePart::WeekOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"week\" not recognized");
 }
 
+template <>
+int64_t DatePart::WeekOperator::Operation(dtime_ns_t input) {
+	return WeekOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::WeekOperator::Operation(dtime_tz_t input) {
 	return WeekOperator::Operation<dtime_t, int64_t>(input.time());
@@ -996,6 +1034,11 @@ int64_t DatePart::ISOYearOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"isoyear\" not recognized");
 }
 
+template <>
+int64_t DatePart::ISOYearOperator::Operation(dtime_ns_t input) {
+	return ISOYearOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::ISOYearOperator::Operation(dtime_tz_t input) {
 	return ISOYearOperator::Operation<dtime_t, int64_t>(input.time());
@@ -1018,6 +1061,11 @@ int64_t DatePart::YearWeekOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"yearweek\" not recognized");
 }
 
+template <>
+int64_t DatePart::YearWeekOperator::Operation(dtime_ns_t input) {
+	return YearWeekOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::YearWeekOperator::Operation(dtime_tz_t input) {
 	return YearWeekOperator::Operation<dtime_t, int64_t>(input.time());
@@ -1045,6 +1093,11 @@ int64_t DatePart::EpochNanosecondsOperator::Operation(dtime_t input) {
 	return input.micros * Interval::NANOS_PER_MICRO;
 }
 
+template <>
+int64_t DatePart::EpochNanosecondsOperator::Operation(dtime_ns_t input) {
+	return input.micros;
+}
+
 template <>
 int64_t DatePart::EpochNanosecondsOperator::Operation(dtime_tz_t input) {
 	return DatePart::EpochNanosecondsOperator::Operation<dtime_t, int64_t>(input.time());
@@ -1071,6 +1124,11 @@ int64_t DatePart::EpochMicrosecondsOperator::Operation(dtime_t input) {
 	return input.micros;
 }
 
+template <>
+int64_t DatePart::EpochMicrosecondsOperator::Operation(dtime_ns_t input) {
+	return DatePart::EpochMicrosecondsOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::EpochMicrosecondsOperator::Operation(dtime_tz_t input) {
 	return DatePart::EpochMicrosecondsOperator::Operation<dtime_t, int64_t>(input.time());
@@ -1109,6 +1167,11 @@ int64_t DatePart::NanosecondsOperator::Operation(timestamp_ns_t input) {
 	return (time.micros % Interval::MICROS_PER_MINUTE) * Interval::NANOS_PER_MICRO + nanos;
 }
 
+template <>
+int64_t DatePart::NanosecondsOperator::Operation(dtime_ns_t input) {
+	return input.micros % Interval::NANOS_PER_MINUTE;
+}
+
 template <>
 int64_t DatePart::MicrosecondsOperator::Operation(timestamp_t input) {
 	D_ASSERT(Timestamp::IsFinite(input));
@@ -1129,6 +1192,11 @@ int64_t DatePart::MicrosecondsOperator::Operation(dtime_t input) {
 	return input.micros % Interval::MICROS_PER_MINUTE;
 }
 
+template <>
+int64_t DatePart::MicrosecondsOperator::Operation(dtime_ns_t input) {
+	return DatePart::MicrosecondsOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::MicrosecondsOperator::Operation(dtime_tz_t input) {
 	return DatePart::MicrosecondsOperator::Operation<dtime_t, int64_t>(input.time());
@@ -1150,6 +1218,11 @@ int64_t DatePart::MillisecondsOperator::Operation(dtime_t input) {
 	return MicrosecondsOperator::Operation<dtime_t, int64_t>(input) / Interval::MICROS_PER_MSEC;
 }
 
+template <>
+int64_t DatePart::MillisecondsOperator::Operation(dtime_ns_t input) {
+	return MillisecondsOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::MillisecondsOperator::Operation(dtime_tz_t input) {
 	return DatePart::MillisecondsOperator::Operation<dtime_t, int64_t>(input.time());
@@ -1171,6 +1244,11 @@ int64_t DatePart::SecondsOperator::Operation(dtime_t input) {
 	return MicrosecondsOperator::Operation<dtime_t, int64_t>(input) / Interval::MICROS_PER_SEC;
 }
 
+template <>
+int64_t DatePart::SecondsOperator::Operation(dtime_ns_t input) {
+	return SecondsOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::SecondsOperator::Operation(dtime_tz_t input) {
 	return DatePart::SecondsOperator::Operation<dtime_t, int64_t>(input.time());
@@ -1196,6 +1274,11 @@ int64_t DatePart::MinutesOperator::Operation(dtime_t input) {
 	return (input.micros % Interval::MICROS_PER_HOUR) / Interval::MICROS_PER_MINUTE;
 }
 
+template <>
+int64_t DatePart::MinutesOperator::Operation(dtime_ns_t input) {
+	return MinutesOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::MinutesOperator::Operation(dtime_tz_t input) {
 	return DatePart::MinutesOperator::Operation<dtime_t, int64_t>(input.time());
@@ -1217,6 +1300,11 @@ int64_t DatePart::HoursOperator::Operation(dtime_t input) {
 	return input.micros / Interval::MICROS_PER_HOUR;
 }
 
+template <>
+int64_t DatePart::HoursOperator::Operation(dtime_ns_t input) {
+	return HoursOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::HoursOperator::Operation(dtime_tz_t input) {
 	return DatePart::HoursOperator::Operation<dtime_t, int64_t>(input.time());
@@ -1254,6 +1342,11 @@ double DatePart::EpochOperator::Operation(dtime_t input) {
 	return double(input.micros) / double(Interval::MICROS_PER_SEC);
 }
 
+template <>
+double DatePart::EpochOperator::Operation(dtime_ns_t input) {
+	return EpochOperator::Operation<dtime_t, double>(input.time());
+}
+
 template <>
 double DatePart::EpochOperator::Operation(dtime_tz_t input) {
 	return DatePart::EpochOperator::Operation<dtime_t, double>(input.time());
@@ -1285,6 +1378,11 @@ int64_t DatePart::EraOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"era\" not recognized");
 }
 
+template <>
+int64_t DatePart::EraOperator::Operation(dtime_ns_t input) {
+	return EraOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::EraOperator::Operation(dtime_tz_t input) {
 	return EraOperator::Operation<dtime_t, int64_t>(input.time());
@@ -1340,21 +1438,6 @@ double DatePart::JulianDayOperator::Operation(date_t input) {
 	return double(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 <>
-double DatePart::JulianDayOperator::Operation(dtime_tz_t input) {
-	return JulianDayOperator::Operation<dtime_t, double>(input.time());
-}
-
 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) {
@@ -1406,6 +1489,57 @@ void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &
 	}
 }
 
+template <>
+void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &double_values, const dtime_ns_t &input,
+                                         const idx_t idx, const part_mask_t mask) {
+	int64_t *part_data;
+	if (mask & TIME) {
+		const auto micros = MicrosecondsOperator::Operation<dtime_ns_t, int64_t>(input);
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MICROSECONDS);
+		if (part_data) {
+			part_data[idx] = micros;
+		}
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MILLISECONDS);
+		if (part_data) {
+			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
+		}
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::SECOND);
+		if (part_data) {
+			part_data[idx] = micros / Interval::MICROS_PER_SEC;
+		}
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::MINUTE);
+		if (part_data) {
+			part_data[idx] = MinutesOperator::Operation<dtime_ns_t, int64_t>(input);
+		}
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::HOUR);
+		if (part_data) {
+			part_data[idx] = HoursOperator::Operation<dtime_ns_t, int64_t>(input);
+		}
+	}
+
+	if (mask & EPOCH) {
+		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
+		if (part_data) {
+			part_data[idx] = EpochOperator::Operation<dtime_ns_t, double>(input);
+		}
+	}
+
+	if (mask & ZONE) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE);
+		if (part_data) {
+			part_data[idx] = 0;
+		}
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE_HOUR);
+		if (part_data) {
+			part_data[idx] = 0;
+		}
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE_MINUTE);
+		if (part_data) {
+			part_data[idx] = 0;
+		}
+	}
+}
+
 template <>
 void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &double_values, const dtime_tz_t &input,
                                          const idx_t idx, const part_mask_t mask) {
@@ -1555,7 +1689,7 @@ void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &
 }
 
 template <typename T>
-static int64_t ExtractElement(DatePartSpecifier type, T element) {
+int64_t ExtractElement(DatePartSpecifier type, T element) {
 	switch (type) {
 	case DatePartSpecifier::YEAR:
 		return DatePart::YearOperator::template Operation<T, int64_t>(element);
@@ -1607,7 +1741,7 @@ static int64_t ExtractElement(DatePartSpecifier type, T element) {
 }
 
 template <typename T>
-static void DatePartFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void DatePartFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 2);
 	auto &spec_arg = args.data[0];
 	auto &date_arg = args.data[1];
@@ -1623,8 +1757,8 @@ static void DatePartFunction(DataChunk &args, ExpressionState &state, Vector &re
 	    });
 }
 
-static unique_ptr<FunctionData> DatePartBind(ClientContext &context, ScalarFunction &bound_function,
-                                             vector<unique_ptr<Expression>> &arguments) {
+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()) {
@@ -1680,6 +1814,10 @@ static unique_ptr<FunctionData> DatePartBind(ClientContext &context, ScalarFunct
 			bound_function.function = DatePart::UnaryFunction<dtime_t, double, DatePart::EpochOperator>;
 			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<dtime_t>;
 			break;
+		case LogicalType::TIME_NS:
+			bound_function.function = DatePart::UnaryFunction<dtime_ns_t, double, DatePart::EpochOperator>;
+			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<dtime_ns_t>;
+			break;
 		case LogicalType::TIME_TZ:
 			bound_function.function = DatePart::UnaryFunction<dtime_tz_t, double, DatePart::EpochOperator>;
 			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<dtime_tz_t>;
@@ -1712,7 +1850,7 @@ ScalarFunctionSet GetGenericDatePartFunction(scalar_function_t date_func, scalar
 }
 
 template <class OP>
-static ScalarFunctionSet GetDatePartFunction() {
+ScalarFunctionSet GetDatePartFunction() {
 	return GetGenericDatePartFunction(
 	    DatePart::UnaryFunction<date_t, int64_t, OP>, DatePart::UnaryFunction<timestamp_t, int64_t, OP>,
 	    ScalarFunction::UnaryFunction<interval_t, int64_t, OP>, OP::template PropagateStatistics<date_t>,
@@ -1721,9 +1859,10 @@ static ScalarFunctionSet GetDatePartFunction() {
 
 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, scalar_function_t timetz_func,
-                                             function_statistics_t date_stats, function_statistics_t ts_stats,
-                                             function_statistics_t time_stats, function_statistics_t timetz_stats) {
+                                             scalar_function_t time_func, scalar_function_t time_ns_func,
+                                             scalar_function_t timetz_func, function_statistics_t date_stats,
+                                             function_statistics_t ts_stats, function_statistics_t time_stats,
+                                             function_statistics_t time_ns_stats, function_statistics_t timetz_stats) {
 	ScalarFunctionSet operator_set;
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::DATE}, result_type, std::move(date_func), nullptr, nullptr, date_stats));
@@ -1732,18 +1871,21 @@ ScalarFunctionSet GetGenericTimePartFunction(const LogicalType &result_type, sca
 	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, result_type, std::move(interval_func)));
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::TIME}, result_type, std::move(time_func), nullptr, nullptr, time_stats));
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::TIME_NS}, result_type, std::move(time_ns_func), nullptr, nullptr, time_ns_stats));
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::TIME_TZ}, result_type, std::move(timetz_func), nullptr, nullptr, timetz_stats));
 	return operator_set;
 }
 
 template <class OP, class TR = int64_t>
-static ScalarFunctionSet GetTimePartFunction(const LogicalType &result_type = LogicalType::BIGINT) {
+ScalarFunctionSet GetTimePartFunction(const LogicalType &result_type = LogicalType::BIGINT) {
 	return GetGenericTimePartFunction(
 	    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>,
-	    ScalarFunction::UnaryFunction<dtime_tz_t, TR, OP>, OP::template PropagateStatistics<date_t>,
-	    OP::template PropagateStatistics<timestamp_t>, OP::template PropagateStatistics<dtime_t>,
+	    ScalarFunction::UnaryFunction<dtime_ns_t, TR, OP>, ScalarFunction::UnaryFunction<dtime_tz_t, TR, OP>,
+	    OP::template PropagateStatistics<date_t>, OP::template PropagateStatistics<timestamp_t>,
+	    OP::template PropagateStatistics<dtime_t>, OP::template PropagateStatistics<dtime_ns_t>,
 	    OP::template PropagateStatistics<dtime_tz_t>);
 }
 
@@ -1993,6 +2135,8 @@ ScalarFunctionSet GetCachedDatepartFunction() {
 	    OP::template PropagateStatistics<timestamp_t>);
 }
 
+} // namespace
+
 ScalarFunctionSet YearFun::GetFunctions() {
 	return GetCachedDatepartFunction<DatePart::YearOperator>();
 }
@@ -2127,13 +2271,20 @@ ScalarFunctionSet EpochMsFun::GetFunctions() {
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
 
-	//	Legacy inverse BIGINT => TIMESTAMP
+	//	Deprecated inverse BIGINT => TIMESTAMP
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, DatePart::EpochMillisOperator::Inverse));
 
 	return operator_set;
 }
 
+ScalarFunctionSet MakeTimestampMsFun::GetFunctions() {
+	ScalarFunctionSet operator_set("make_timestamp_ms");
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, DatePart::EpochMillisOperator::Inverse));
+	return operator_set;
+}
+
 ScalarFunctionSet NanosecondsFun::GetFunctions() {
 	using OP = DatePart::NanosecondsOperator;
 	using TR = int64_t;
@@ -2241,6 +2392,8 @@ ScalarFunctionSet DatePartFun::GetFunctions() {
 	                                     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::TIME_NS}, LogicalType::BIGINT,
+	                                     DatePartFunction<dtime_ns_t>, DatePartBind));
 	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::BIGINT,
 	                                     DatePartFunction<interval_t>, DatePartBind));
 	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME_TZ}, LogicalType::BIGINT,
@@ -2250,6 +2403,7 @@ ScalarFunctionSet DatePartFun::GetFunctions() {
 	date_part.AddFunction(StructDatePart::GetFunction<date_t>(LogicalType::DATE));
 	date_part.AddFunction(StructDatePart::GetFunction<timestamp_t>(LogicalType::TIMESTAMP));
 	date_part.AddFunction(StructDatePart::GetFunction<dtime_t>(LogicalType::TIME));
+	date_part.AddFunction(StructDatePart::GetFunction<dtime_ns_t>(LogicalType::TIME_NS));
 	date_part.AddFunction(StructDatePart::GetFunction<interval_t>(LogicalType::INTERVAL));
 	date_part.AddFunction(StructDatePart::GetFunction<dtime_tz_t>(LogicalType::TIME_TZ));
 

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

@@ -12,6 +12,8 @@
 
 namespace duckdb {
 
+namespace {
+
 struct DateSub {
 	static int64_t SubtractMicros(timestamp_t startdate, timestamp_t enddate) {
 		const auto start = Timestamp::GetEpochMicroSeconds(startdate);
@@ -311,7 +313,7 @@ int64_t DateSub::HoursOperator::Operation(dtime_t startdate, dtime_t enddate) {
 }
 
 template <typename TA, typename TB, typename TR>
-static int64_t SubtractDateParts(DatePartSpecifier type, TA startdate, TB enddate) {
+int64_t SubtractDateParts(DatePartSpecifier type, TA startdate, TB enddate) {
 	switch (type) {
 	case DatePartSpecifier::YEAR:
 	case DatePartSpecifier::ISOYEAR:
@@ -364,7 +366,7 @@ struct DateSubTernaryOperator {
 };
 
 template <typename TA, typename TB, typename TR>
-static void DateSubBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right, Vector &result, idx_t count) {
+void DateSubBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right, Vector &result, idx_t count) {
 	switch (type) {
 	case DatePartSpecifier::YEAR:
 	case DatePartSpecifier::ISOYEAR:
@@ -418,7 +420,7 @@ static void DateSubBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &
 }
 
 template <typename T>
-static void DateSubFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void DateSubFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 3);
 	auto &part_arg = args.data[0];
 	auto &start_arg = args.data[1];
@@ -440,6 +442,8 @@ static void DateSubFunction(DataChunk &args, ExpressionState &state, Vector &res
 	}
 }
 
+} // namespace
+
 ScalarFunctionSet DateSubFun::GetFunctions() {
 	ScalarFunctionSet date_sub("date_sub");
 	date_sub.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE, LogicalType::DATE},