duckdb 1.3.3-dev4.0 → 1.3.3

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

@@ -55,8 +55,6 @@ ScalarFunctionSet BitStringFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // get_bit
 //===--------------------------------------------------------------------===//
-namespace {
-
 struct GetBitOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA input, TB n) {
@@ -68,7 +66,6 @@ struct GetBitOperator {
 	}
 };
 
-} // namespace
 ScalarFunction GetBitFun::GetFunction() {
 	ScalarFunction func({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::INTEGER,
 	                    ScalarFunction::BinaryFunction<string_t, int32_t, int32_t, GetBitOperator>);
@@ -107,8 +104,6 @@ ScalarFunction SetBitFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // bit_position
 //===--------------------------------------------------------------------===//
-namespace {
-
 struct BitPositionOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA substring, TB input) {
@@ -119,8 +114,6 @@ 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,7 +3,6 @@
 
 namespace duckdb {
 
-namespace {
 struct Base64EncodeOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
@@ -25,18 +24,16 @@ struct Base64DecodeOperator {
 	}
 };
 
-void Base64EncodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static 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());
 }
 
-void Base64DecodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static 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,9 +4,7 @@
 
 namespace duckdb {
 
-namespace {
-
-void EncodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static 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]);
@@ -25,14 +23,12 @@ struct BlobDecodeOperator {
 	}
 };
 
-void DecodeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static 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,8 +14,6 @@ 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) {
@@ -310,7 +308,7 @@ int64_t DateDiff::HoursOperator::Operation(dtime_t startdate, dtime_t enddate) {
 }
 
 template <typename TA, typename TB, typename TR>
-int64_t DifferenceDates(DatePartSpecifier type, TA startdate, TB enddate) {
+static int64_t DifferenceDates(DatePartSpecifier type, TA startdate, TB enddate) {
 	switch (type) {
 	case DatePartSpecifier::YEAR:
 		return DateDiff::YearOperator::template Operation<TA, TB, TR>(startdate, enddate);
@@ -364,7 +362,7 @@ struct DateDiffTernaryOperator {
 };
 
 template <typename TA, typename TB, typename TR>
-void DateDiffBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right, Vector &result, idx_t count) {
+static 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);
@@ -420,7 +418,7 @@ void DateDiffBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right,
 }
 
 template <typename T>
-void DateDiffFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static 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];
@@ -442,8 +440,6 @@ void DateDiffFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	}
 }
 
-} // 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,15 +5,18 @@
 #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()) {
@@ -44,7 +47,6 @@ DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType
 		}
 		break;
 	case LogicalType::TIME:
-	case LogicalType::TIME_NS:
 	case LogicalType::TIME_TZ:
 		switch (part) {
 		case DatePartSpecifier::MICROSECONDS:
@@ -89,7 +91,7 @@ DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType
 }
 
 template <int64_t MIN, int64_t MAX>
-unique_ptr<BaseStatistics> PropagateSimpleDatePartStatistics(vector<BaseStatistics> &child_stats) {
+static 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);
@@ -767,7 +769,7 @@ struct DatePart {
 };
 
 template <class OP, class T>
-void DatePartCachedFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static 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(),
@@ -789,11 +791,6 @@ 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());
@@ -814,11 +811,6 @@ 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());
@@ -839,11 +831,6 @@ 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());
@@ -909,11 +896,6 @@ 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());
@@ -934,11 +916,6 @@ 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());
@@ -959,11 +936,6 @@ 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());
@@ -984,11 +956,6 @@ 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());
@@ -1009,11 +976,6 @@ 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());
@@ -1034,11 +996,6 @@ 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());
@@ -1061,11 +1018,6 @@ 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());
@@ -1093,11 +1045,6 @@ 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());
@@ -1124,11 +1071,6 @@ 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());
@@ -1167,11 +1109,6 @@ 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));
@@ -1192,11 +1129,6 @@ 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());
@@ -1218,11 +1150,6 @@ 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());
@@ -1244,11 +1171,6 @@ 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());
@@ -1274,11 +1196,6 @@ 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());
@@ -1300,11 +1217,6 @@ 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());
@@ -1342,11 +1254,6 @@ 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());
@@ -1378,11 +1285,6 @@ 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());
@@ -1439,62 +1341,26 @@ double DatePart::JulianDayOperator::Operation(date_t input) {
 }
 
 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(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_t, int64_t>(input);
-		}
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::HOUR);
-		if (part_data) {
-			part_data[idx] = HoursOperator::Operation<dtime_t, int64_t>(input);
-		}
-	}
+double DatePart::JulianDayOperator::Operation(interval_t input) {
+	throw NotImplementedException("interval units \"julian\" not recognized");
+}
 
-	if (mask & EPOCH) {
-		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
-		if (part_data) {
-			part_data[idx] = EpochOperator::Operation<dtime_t, double>(input);
-		}
-	}
+template <>
+double DatePart::JulianDayOperator::Operation(dtime_t input) {
+	throw NotImplementedException("\"time\" units \"julian\" not recognized");
+}
 
-	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 <>
+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_ns_t &input,
+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_ns_t, int64_t>(input);
+		const auto micros = MicrosecondsOperator::Operation<dtime_t, int64_t>(input);
 		part_data = HasPartValue(bigint_values, DatePartSpecifier::MICROSECONDS);
 		if (part_data) {
 			part_data[idx] = micros;
@@ -1509,18 +1375,18 @@ void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &
 		}
 		part_data = HasPartValue(bigint_values, DatePartSpecifier::MINUTE);
 		if (part_data) {
-			part_data[idx] = MinutesOperator::Operation<dtime_ns_t, int64_t>(input);
+			part_data[idx] = MinutesOperator::Operation<dtime_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);
+			part_data[idx] = HoursOperator::Operation<dtime_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);
+			part_data[idx] = EpochOperator::Operation<dtime_t, double>(input);
 		}
 	}
 
@@ -1689,7 +1555,7 @@ void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &
 }
 
 template <typename T>
-int64_t ExtractElement(DatePartSpecifier type, T element) {
+static int64_t ExtractElement(DatePartSpecifier type, T element) {
 	switch (type) {
 	case DatePartSpecifier::YEAR:
 		return DatePart::YearOperator::template Operation<T, int64_t>(element);
@@ -1741,7 +1607,7 @@ int64_t ExtractElement(DatePartSpecifier type, T element) {
 }
 
 template <typename T>
-void DatePartFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static 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];
@@ -1757,8 +1623,8 @@ void DatePartFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	    });
 }
 
-unique_ptr<FunctionData> DatePartBind(ClientContext &context, ScalarFunction &bound_function,
-                                      vector<unique_ptr<Expression>> &arguments) {
+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()) {
@@ -1814,10 +1680,6 @@ unique_ptr<FunctionData> DatePartBind(ClientContext &context, ScalarFunction &bo
 			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>;
@@ -1850,7 +1712,7 @@ ScalarFunctionSet GetGenericDatePartFunction(scalar_function_t date_func, scalar
 }
 
 template <class OP>
-ScalarFunctionSet GetDatePartFunction() {
+static 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>,
@@ -1859,10 +1721,9 @@ 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 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) {
+                                             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) {
 	ScalarFunctionSet operator_set;
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::DATE}, result_type, std::move(date_func), nullptr, nullptr, date_stats));
@@ -1871,21 +1732,18 @@ 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>
-ScalarFunctionSet GetTimePartFunction(const LogicalType &result_type = LogicalType::BIGINT) {
+static 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_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>,
+	    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_tz_t>);
 }
 
@@ -2135,8 +1993,6 @@ ScalarFunctionSet GetCachedDatepartFunction() {
 	    OP::template PropagateStatistics<timestamp_t>);
 }
 
-} // namespace
-
 ScalarFunctionSet YearFun::GetFunctions() {
 	return GetCachedDatepartFunction<DatePart::YearOperator>();
 }
@@ -2271,20 +2127,13 @@ ScalarFunctionSet EpochMsFun::GetFunctions() {
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
 
-	//	Deprecated inverse BIGINT => TIMESTAMP
+	//	Legacy 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;
@@ -2392,8 +2241,6 @@ 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,
@@ -2403,7 +2250,6 @@ 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));