duckdb 0.9.3-dev0.0 → 0.9.3-dev14.0

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

@@ -35,19 +35,19 @@ static void CurrentTimestampFunction(DataChunk &input, ExpressionState &state, V
 
 ScalarFunction CurrentTimeFun::GetFunction() {
 	ScalarFunction current_time({}, LogicalType::TIME, CurrentTimeFunction);
-	current_time.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
+	current_time.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
 	return current_time;
 }
 
 ScalarFunction CurrentDateFun::GetFunction() {
 	ScalarFunction current_date({}, LogicalType::DATE, CurrentDateFunction);
-	current_date.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
+	current_date.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
 	return current_date;
 }
 
 ScalarFunction GetCurrentTimestampFun::GetFunction() {
 	ScalarFunction current_timestamp({}, LogicalType::TIMESTAMP_TZ, CurrentTimestampFunction);
-	current_timestamp.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
+	current_timestamp.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
 	return current_timestamp;
 }
 

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

@@ -5,6 +5,7 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/types/date.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"
@@ -43,6 +44,7 @@ DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType
 		}
 		break;
 	case LogicalType::TIME:
+	case LogicalType::TIME_TZ:
 		switch (part) {
 		case DatePartSpecifier::MICROSECONDS:
 		case DatePartSpecifier::MILLISECONDS:
@@ -358,7 +360,7 @@ struct DatePart {
 	struct EpochNanosecondsOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			return input.micros * Interval::NANOS_PER_MICRO;
+			return Timestamp::GetEpochNanoSeconds(input);
 		}
 
 		template <class T>
@@ -370,7 +372,7 @@ struct DatePart {
 	struct EpochMicrosecondsOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			return input.micros;
+			return Timestamp::GetEpochMicroSeconds(input);
 		}
 
 		template <class T>
@@ -382,7 +384,7 @@ struct DatePart {
 	struct EpochMillisOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			return input.micros / Interval::MICROS_PER_MSEC;
+			return Timestamp::GetEpochMs(input);
 		}
 
 		template <class T>
@@ -494,6 +496,51 @@ struct DatePart {
 			return 0;
 		}
 
+		template <typename TA, typename TB, typename TR>
+		static TR Operation(TA interval, TB timetz) {
+			auto time = Time::NormalizeTimeTZ(timetz);
+			date_t date(0);
+			time = Interval::Add(time, interval, date);
+			auto offset = interval.micros / Interval::MICROS_PER_SEC;
+			return TR(time, offset);
+		}
+
+		template <typename TA, typename TB, typename TR>
+		static void BinaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+			D_ASSERT(input.ColumnCount() == 2);
+			auto &offset = input.data[0];
+			auto &timetz = input.data[1];
+
+			auto func = DatePart::TimezoneOperator::Operation<TA, TB, TR>;
+			BinaryExecutor::Execute<TA, TB, TR>(offset, timetz, result, input.size(), func);
+		}
+
+		template <class T>
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<0, 0>(input.child_stats);
+		}
+	};
+
+	struct TimezoneHourOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			// Regular timestamps are UTC.
+			return 0;
+		}
+
+		template <class T>
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<0, 0>(input.child_stats);
+		}
+	};
+
+	struct TimezoneMinuteOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			// Regular timestamps are UTC.
+			return 0;
+		}
+
 		template <class T>
 		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
 			return PropagateSimpleDatePartStatistics<0, 0>(input.child_stats);
@@ -512,10 +559,6 @@ struct DatePart {
 		}
 	};
 
-	// These are all zero and have the same restrictions
-	using TimezoneHourOperator = TimezoneOperator;
-	using TimezoneMinuteOperator = TimezoneOperator;
-
 	struct StructOperator {
 		using part_codes_t = vector<DatePartSpecifier>;
 		using part_mask_t = uint64_t;
@@ -722,6 +765,11 @@ int64_t DatePart::YearOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"year\" not recognized");
 }
 
+template <>
+int64_t DatePart::YearOperator::Operation(dtime_tz_t input) {
+	return YearOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::MonthOperator::Operation(timestamp_t input) {
 	return MonthOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
@@ -737,6 +785,11 @@ int64_t DatePart::MonthOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"month\" not recognized");
 }
 
+template <>
+int64_t DatePart::MonthOperator::Operation(dtime_tz_t input) {
+	return MonthOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::DayOperator::Operation(timestamp_t input) {
 	return DayOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
@@ -752,6 +805,11 @@ int64_t DatePart::DayOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"day\" not recognized");
 }
 
+template <>
+int64_t DatePart::DayOperator::Operation(dtime_tz_t input) {
+	return DayOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::DecadeOperator::Operation(interval_t input) {
 	return input.months / Interval::MONTHS_PER_DECADE;
@@ -762,6 +820,11 @@ int64_t DatePart::DecadeOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"decade\" not recognized");
 }
 
+template <>
+int64_t DatePart::DecadeOperator::Operation(dtime_tz_t input) {
+	return DecadeOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::CenturyOperator::Operation(interval_t input) {
 	return input.months / Interval::MONTHS_PER_CENTURY;
@@ -772,6 +835,11 @@ int64_t DatePart::CenturyOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"century\" not recognized");
 }
 
+template <>
+int64_t DatePart::CenturyOperator::Operation(dtime_tz_t input) {
+	return CenturyOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::MillenniumOperator::Operation(interval_t input) {
 	return input.months / Interval::MONTHS_PER_MILLENIUM;
@@ -782,6 +850,11 @@ int64_t DatePart::MillenniumOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"millennium\" not recognized");
 }
 
+template <>
+int64_t DatePart::MillenniumOperator::Operation(dtime_tz_t input) {
+	return MillenniumOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::QuarterOperator::Operation(timestamp_t input) {
 	return QuarterOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
@@ -797,6 +870,11 @@ int64_t DatePart::QuarterOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"quarter\" not recognized");
 }
 
+template <>
+int64_t DatePart::QuarterOperator::Operation(dtime_tz_t input) {
+	return QuarterOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::DayOfWeekOperator::Operation(timestamp_t input) {
 	return DayOfWeekOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
@@ -812,6 +890,11 @@ int64_t DatePart::DayOfWeekOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"dow\" not recognized");
 }
 
+template <>
+int64_t DatePart::DayOfWeekOperator::Operation(dtime_tz_t input) {
+	return DayOfWeekOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::ISODayOfWeekOperator::Operation(timestamp_t input) {
 	return ISODayOfWeekOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
@@ -827,6 +910,11 @@ int64_t DatePart::ISODayOfWeekOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"isodow\" not recognized");
 }
 
+template <>
+int64_t DatePart::ISODayOfWeekOperator::Operation(dtime_tz_t input) {
+	return ISODayOfWeekOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::DayOfYearOperator::Operation(timestamp_t input) {
 	return DayOfYearOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
@@ -842,6 +930,11 @@ int64_t DatePart::DayOfYearOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"doy\" not recognized");
 }
 
+template <>
+int64_t DatePart::DayOfYearOperator::Operation(dtime_tz_t input) {
+	return DayOfYearOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::WeekOperator::Operation(timestamp_t input) {
 	return WeekOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
@@ -857,6 +950,11 @@ int64_t DatePart::WeekOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"week\" not recognized");
 }
 
+template <>
+int64_t DatePart::WeekOperator::Operation(dtime_tz_t input) {
+	return WeekOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::ISOYearOperator::Operation(timestamp_t input) {
 	return ISOYearOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
@@ -872,6 +970,11 @@ int64_t DatePart::ISOYearOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"isoyear\" not recognized");
 }
 
+template <>
+int64_t DatePart::ISOYearOperator::Operation(dtime_tz_t input) {
+	return ISOYearOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::YearWeekOperator::Operation(timestamp_t input) {
 	return YearWeekOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
@@ -889,6 +992,11 @@ int64_t DatePart::YearWeekOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"yearweek\" not recognized");
 }
 
+template <>
+int64_t DatePart::YearWeekOperator::Operation(dtime_tz_t input) {
+	return YearWeekOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::EpochNanosecondsOperator::Operation(timestamp_t input) {
 	return Timestamp::GetEpochNanoSeconds(input);
@@ -905,8 +1013,13 @@ int64_t DatePart::EpochNanosecondsOperator::Operation(interval_t input) {
 }
 
 template <>
-int64_t DatePart::EpochMicrosecondsOperator::Operation(timestamp_t input) {
-	return Timestamp::GetEpochMicroSeconds(input);
+int64_t DatePart::EpochNanosecondsOperator::Operation(dtime_t input) {
+	return input.micros * Interval::NANOS_PER_MICRO;
+}
+
+template <>
+int64_t DatePart::EpochNanosecondsOperator::Operation(dtime_tz_t input) {
+	return DatePart::EpochNanosecondsOperator::Operation<dtime_t, int64_t>(input.time());
 }
 
 template <>
@@ -920,8 +1033,13 @@ int64_t DatePart::EpochMicrosecondsOperator::Operation(interval_t input) {
 }
 
 template <>
-int64_t DatePart::EpochMillisOperator::Operation(timestamp_t input) {
-	return Timestamp::GetEpochMs(input);
+int64_t DatePart::EpochMicrosecondsOperator::Operation(dtime_t input) {
+	return input.micros;
+}
+
+template <>
+int64_t DatePart::EpochMicrosecondsOperator::Operation(dtime_tz_t input) {
+	return DatePart::EpochMicrosecondsOperator::Operation<dtime_t, int64_t>(input.time());
 }
 
 template <>
@@ -934,6 +1052,16 @@ int64_t DatePart::EpochMillisOperator::Operation(interval_t input) {
 	return Interval::GetMilli(input);
 }
 
+template <>
+int64_t DatePart::EpochMillisOperator::Operation(dtime_t input) {
+	return input.micros / Interval::MICROS_PER_MSEC;
+}
+
+template <>
+int64_t DatePart::EpochMillisOperator::Operation(dtime_tz_t input) {
+	return DatePart::EpochMillisOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::MicrosecondsOperator::Operation(timestamp_t input) {
 	auto time = Timestamp::GetTime(input);
@@ -953,6 +1081,11 @@ int64_t DatePart::MicrosecondsOperator::Operation(dtime_t input) {
 	return input.micros % Interval::MICROS_PER_MINUTE;
 }
 
+template <>
+int64_t DatePart::MicrosecondsOperator::Operation(dtime_tz_t input) {
+	return DatePart::MicrosecondsOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::MillisecondsOperator::Operation(timestamp_t input) {
 	return MicrosecondsOperator::Operation<timestamp_t, int64_t>(input) / Interval::MICROS_PER_MSEC;
@@ -968,6 +1101,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_tz_t input) {
+	return DatePart::MillisecondsOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::SecondsOperator::Operation(timestamp_t input) {
 	return MicrosecondsOperator::Operation<timestamp_t, int64_t>(input) / Interval::MICROS_PER_SEC;
@@ -983,6 +1121,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_tz_t input) {
+	return DatePart::SecondsOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::MinutesOperator::Operation(timestamp_t input) {
 	auto time = Timestamp::GetTime(input);
@@ -1002,6 +1145,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_tz_t input) {
+	return DatePart::MinutesOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::HoursOperator::Operation(timestamp_t input) {
 	return Timestamp::GetTime(input).micros / Interval::MICROS_PER_HOUR;
@@ -1017,6 +1165,11 @@ int64_t DatePart::HoursOperator::Operation(dtime_t input) {
 	return input.micros / Interval::MICROS_PER_HOUR;
 }
 
+template <>
+int64_t DatePart::HoursOperator::Operation(dtime_tz_t input) {
+	return DatePart::HoursOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 double DatePart::EpochOperator::Operation(timestamp_t input) {
 	return Timestamp::GetEpochMicroSeconds(input) / double(Interval::MICROS_PER_SEC);
@@ -1048,6 +1201,11 @@ double DatePart::EpochOperator::Operation(dtime_t input) {
 	return input.micros / double(Interval::MICROS_PER_SEC);
 }
 
+template <>
+double DatePart::EpochOperator::Operation(dtime_tz_t input) {
+	return DatePart::EpochOperator::Operation<dtime_t, double>(input.time());
+}
+
 template <>
 unique_ptr<BaseStatistics> DatePart::EpochOperator::PropagateStatistics<dtime_t>(ClientContext &context,
                                                                                  FunctionStatisticsInput &input) {
@@ -1073,6 +1231,11 @@ int64_t DatePart::EraOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"era\" not recognized");
 }
 
+template <>
+int64_t DatePart::EraOperator::Operation(dtime_tz_t input) {
+	return EraOperator::Operation<dtime_t, int64_t>(input.time());
+}
+
 template <>
 int64_t DatePart::TimezoneOperator::Operation(date_t input) {
 	throw NotImplementedException("\"date\" units \"timezone\" not recognized");
@@ -1084,8 +1247,38 @@ int64_t DatePart::TimezoneOperator::Operation(interval_t input) {
 }
 
 template <>
-int64_t DatePart::TimezoneOperator::Operation(dtime_t input) {
-	return 0;
+int64_t DatePart::TimezoneOperator::Operation(dtime_tz_t input) {
+	return input.offset();
+}
+
+template <>
+int64_t DatePart::TimezoneHourOperator::Operation(date_t input) {
+	throw NotImplementedException("\"date\" units \"timezone_hour\" not recognized");
+}
+
+template <>
+int64_t DatePart::TimezoneHourOperator::Operation(interval_t input) {
+	throw NotImplementedException("\"interval\" units \"timezone_hour\" not recognized");
+}
+
+template <>
+int64_t DatePart::TimezoneHourOperator::Operation(dtime_tz_t input) {
+	return input.offset() / Interval::SECS_PER_HOUR;
+}
+
+template <>
+int64_t DatePart::TimezoneMinuteOperator::Operation(date_t input) {
+	throw NotImplementedException("\"date\" units \"timezone_minute\" not recognized");
+}
+
+template <>
+int64_t DatePart::TimezoneMinuteOperator::Operation(interval_t input) {
+	throw NotImplementedException("\"interval\" units \"timezone_minute\" not recognized");
+}
+
+template <>
+int64_t DatePart::TimezoneMinuteOperator::Operation(dtime_tz_t input) {
+	return (input.offset() / Interval::SECS_PER_MINUTE) % Interval::MINS_PER_HOUR;
 }
 
 template <>
@@ -1103,6 +1296,11 @@ 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) {
@@ -1135,7 +1333,6 @@ void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &
 		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
 		if (part_data) {
 			part_data[idx] = EpochOperator::Operation<dtime_t, double>(input);
-			;
 		}
 	}
 
@@ -1155,6 +1352,58 @@ 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_tz_t &input,
+                                         const idx_t idx, const part_mask_t mask) {
+	int64_t *part_data;
+	if (mask & TIME) {
+		const auto micros = MicrosecondsOperator::Operation<dtime_tz_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_tz_t, int64_t>(input);
+		}
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::HOUR);
+		if (part_data) {
+			part_data[idx] = HoursOperator::Operation<dtime_tz_t, int64_t>(input);
+		}
+	}
+
+	if (mask & EPOCH) {
+		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
+		if (part_data) {
+			part_data[idx] = EpochOperator::Operation<dtime_tz_t, double>(input);
+		}
+	}
+
+	if (mask & ZONE) {
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE);
+		if (part_data) {
+			part_data[idx] = TimezoneOperator::Operation<dtime_tz_t, int64_t>(input);
+		}
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE_HOUR);
+		if (part_data) {
+			part_data[idx] = TimezoneHourOperator::Operation<dtime_tz_t, int64_t>(input);
+		}
+		part_data = HasPartValue(bigint_values, DatePartSpecifier::TIMEZONE_MINUTE);
+		if (part_data) {
+			part_data[idx] = TimezoneMinuteOperator::Operation<dtime_tz_t, int64_t>(input);
+		}
+		return;
+	}
+}
+
 template <>
 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) {
@@ -1292,9 +1541,11 @@ static int64_t ExtractElement(DatePartSpecifier type, T element) {
 	case DatePartSpecifier::ERA:
 		return DatePart::EraOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::TIMEZONE:
+		return DatePart::TimezoneOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::TIMEZONE_HOUR:
+		return DatePart::TimezoneHourOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::TIMEZONE_MINUTE:
-		return DatePart::TimezoneOperator::template Operation<T, int64_t>(element);
+		return DatePart::TimezoneMinuteOperator::template Operation<T, int64_t>(element);
 	default:
 		throw NotImplementedException("Specifier type not implemented for DATEPART");
 	}
@@ -1335,6 +1586,9 @@ static unique_ptr<FunctionData> DatePartBind(ClientContext &context, ScalarFunct
 		bound_function.return_type = LogicalType::DOUBLE;
 		switch (arguments[0]->return_type.id()) {
 		case LogicalType::TIMESTAMP:
+		case LogicalType::TIMESTAMP_S:
+		case LogicalType::TIMESTAMP_MS:
+		case LogicalType::TIMESTAMP_NS:
 			bound_function.function = DatePart::UnaryFunction<timestamp_t, double, DatePart::JulianDayOperator>;
 			bound_function.statistics = DatePart::JulianDayOperator::template PropagateStatistics<timestamp_t>;
 			break;
@@ -1353,6 +1607,9 @@ static unique_ptr<FunctionData> DatePartBind(ClientContext &context, ScalarFunct
 		bound_function.return_type = LogicalType::DOUBLE;
 		switch (arguments[0]->return_type.id()) {
 		case LogicalType::TIMESTAMP:
+		case LogicalType::TIMESTAMP_S:
+		case LogicalType::TIMESTAMP_MS:
+		case LogicalType::TIMESTAMP_NS:
 			bound_function.function = DatePart::UnaryFunction<timestamp_t, double, DatePart::EpochOperator>;
 			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<timestamp_t>;
 			break;
@@ -1368,6 +1625,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_TZ:
+			bound_function.function = DatePart::UnaryFunction<dtime_tz_t, double, DatePart::EpochOperator>;
+			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<dtime_tz_t>;
+			break;
 		default:
 			throw BinderException("%s can only take temporal arguments", bound_function.name);
 		}
@@ -1401,8 +1662,9 @@ 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, function_statistics_t date_stats,
-                                             function_statistics_t ts_stats, function_statistics_t time_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));
@@ -1411,6 +1673,8 @@ 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_TZ}, result_type, std::move(timetz_func), nullptr, nullptr, timetz_stats));
 	return operator_set;
 }
 
@@ -1419,8 +1683,9 @@ static ScalarFunctionSet GetTimePartFunction(const LogicalType &result_type = Lo
 	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>,
-	    OP::template PropagateStatistics<date_t>, OP::template PropagateStatistics<timestamp_t>,
-	    OP::template PropagateStatistics<dtime_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>);
 }
 
 struct LastDayOperator {
@@ -1718,7 +1983,14 @@ ScalarFunctionSet EraFun::GetFunctions() {
 }
 
 ScalarFunctionSet TimezoneFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::TimezoneOperator>();
+	auto operator_set = GetDatePartFunction<DatePart::TimezoneOperator>();
+
+	//	PG also defines timezone(INTERVAL, TIME_TZ) => TIME_TZ
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::INTERVAL, LogicalType::TIME_TZ}, LogicalType::TIME_TZ,
+	                   DatePart::TimezoneOperator::BinaryFunction<interval_t, dtime_tz_t, dtime_tz_t>));
+
+	return operator_set;
 }
 
 ScalarFunctionSet TimezoneHourFun::GetFunctions() {
@@ -1863,12 +2135,15 @@ ScalarFunctionSet DatePartFun::GetFunctions() {
 	                                     DatePartFunction<dtime_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,
+	                                     DatePartFunction<dtime_tz_t>, DatePartBind));
 
 	// struct variants
 	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<interval_t>(LogicalType::INTERVAL));
+	date_part.AddFunction(StructDatePart::GetFunction<dtime_tz_t>(LogicalType::TIME_TZ));
 
 	return date_part;
 }

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

@@ -4,6 +4,7 @@
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/vector_operations/ternary_executor.hpp"
 #include "duckdb/common/vector_operations/senary_executor.hpp"
+#include "duckdb/common/exception/conversion_exception.hpp"
 
 #include <cmath>