duckdb 0.8.2-dev11.0 → 0.8.2-dev1212.0

package/src/duckdb/src/core_functions/aggregate/regression/regr_r2.cpp

@@ -1,3 +1,4 @@
+// REGR_R2(y, x)
 // Returns the coefficient of determination for non-null pairs in a group.
 // It is computed for non-null pairs using the following formula:
 // null                 if var_pop(x) = 0, else
@@ -24,10 +25,10 @@ struct RegrR2Operation {
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
-		CorrOperation::Operation<A_TYPE, B_TYPE, CorrState, OP>(state.corr, x, y, idata);
-		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop_x, y);
-		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop_y, x);
+	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
+		CorrOperation::Operation<A_TYPE, B_TYPE, CorrState, OP>(state.corr, y, x, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop_x, x);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop_y, y);
 	}
 
 	template <class STATE, class OP>

package/src/duckdb/src/core_functions/aggregate/regression/regr_sxx_syy.cpp

@@ -1,6 +1,6 @@
-// regr_sxx
+// REGR_SXX(y, x)
 // Returns REGR_COUNT(y, x) * VAR_POP(x) for non-null pairs.
-// regrsyy
+// REGR_SYY(y, x)
 // Returns REGR_COUNT(y, x) * VAR_POP(y) for non-null pairs.
 
 #include "duckdb/core_functions/aggregate/regression/regr_count.hpp"
@@ -48,17 +48,17 @@ struct RegrBaseOperation {
 
 struct RegrSXXOperation : RegrBaseOperation {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, x, y, idata);
-		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, y);
+	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
+		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, y, x, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, x);
 	}
 };
 
 struct RegrSYYOperation : RegrBaseOperation {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, x, y, idata);
-		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, x);
+	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
+		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, y, x, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, y);
 	}
 };
 

package/src/duckdb/src/core_functions/aggregate/regression/regr_sxy.cpp

@@ -1,3 +1,4 @@
+// REGR_SXY(y, x)
 // Returns REGR_COUNT(expr1, expr2) * COVAR_POP(expr1, expr2) for non-null pairs.
 
 #include "duckdb/core_functions/aggregate/regression/regr_count.hpp"
@@ -20,9 +21,9 @@ struct RegrSXYOperation {
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, x, y, idata);
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, x, y, idata);
+	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
+		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, y, x, idata);
+		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, y, x, idata);
 	}
 
 	template <class STATE, class OP>

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

@@ -137,7 +137,9 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION(EnumRangeFun),
 	DUCKDB_SCALAR_FUNCTION(EnumRangeBoundaryFun),
 	DUCKDB_SCALAR_FUNCTION_SET(EpochFun),
-	DUCKDB_SCALAR_FUNCTION(EpochMsFun),
+	DUCKDB_SCALAR_FUNCTION_SET(EpochNanosecondsFun),
+	DUCKDB_SCALAR_FUNCTION_SET(EpochMicrosecondsFun),
+	DUCKDB_SCALAR_FUNCTION_SET(EpochMsFun),
 	DUCKDB_SCALAR_FUNCTION_SET(EraFun),
 	DUCKDB_SCALAR_FUNCTION(ErrorFun),
 	DUCKDB_SCALAR_FUNCTION(EvenFun),
@@ -211,7 +213,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_AGGREGATE_FUNCTION_SET(MadFun),
 	DUCKDB_SCALAR_FUNCTION_SET(MakeDateFun),
 	DUCKDB_SCALAR_FUNCTION(MakeTimeFun),
-	DUCKDB_SCALAR_FUNCTION(MakeTimestampFun),
+	DUCKDB_SCALAR_FUNCTION_SET(MakeTimestampFun),
 	DUCKDB_SCALAR_FUNCTION(MapFun),
 	DUCKDB_SCALAR_FUNCTION(MapConcatFun),
 	DUCKDB_SCALAR_FUNCTION(MapEntriesFun),

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

@@ -354,6 +354,49 @@ struct DatePart {
 		}
 	};
 
+	struct EpochNanosecondsOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			return input.micros * Interval::NANOS_PER_MICRO;
+		}
+
+		template <class T>
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, EpochNanosecondsOperator>(input.child_stats);
+		}
+	};
+
+	struct EpochMicrosecondsOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			return input.micros;
+		}
+
+		template <class T>
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, EpochMicrosecondsOperator>(input.child_stats);
+		}
+	};
+
+	struct EpochMillisOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			return input.micros / Interval::MICROS_PER_MSEC;
+		}
+
+		template <class T>
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateDatePartStatistics<T, EpochMillisOperator>(input.child_stats);
+		}
+
+		static void Inverse(DataChunk &input, ExpressionState &state, Vector &result) {
+			D_ASSERT(input.ColumnCount() == 1);
+
+			UnaryExecutor::Execute<int64_t, timestamp_t>(input.data[0], result, input.size(),
+			                                             [&](int64_t input) { return Timestamp::FromEpochMs(input); });
+		}
+	};
+
 	struct MicrosecondsOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
@@ -521,9 +564,8 @@ struct DatePart {
 		}
 
 		template <typename P>
-		static inline bool HasPartValue(P *part_values, DatePartSpecifier part, P &value) {
-			value = part_values[int(part)];
-			return value;
+		static inline P HasPartValue(P *part_values, DatePartSpecifier part) {
+			return part_values[int(part)];
 		}
 
 		template <class TA, class TR>
@@ -535,28 +577,36 @@ struct DatePart {
 			int32_t dd = 1;
 			if (mask & YMD) {
 				Date::Convert(input, yyyy, mm, dd);
-				if (HasPartValue(part_values, DatePartSpecifier::YEAR, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::YEAR);
+				if (part_data) {
 					part_data[idx] = yyyy;
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::MONTH, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::MONTH);
+				if (part_data) {
 					part_data[idx] = mm;
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::DAY, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::DAY);
+				if (part_data) {
 					part_data[idx] = dd;
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::DECADE, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::DECADE);
+				if (part_data) {
 					part_data[idx] = DecadeOperator::DecadeFromYear(yyyy);
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::CENTURY, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::CENTURY);
+				if (part_data) {
 					part_data[idx] = CenturyOperator::CenturyFromYear(yyyy);
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::MILLENNIUM, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::MILLENNIUM);
+				if (part_data) {
 					part_data[idx] = MillenniumOperator::MillenniumFromYear(yyyy);
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::QUARTER, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::QUARTER);
+				if (part_data) {
 					part_data[idx] = QuarterOperator::QuarterFromMonth(mm);
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::ERA, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::ERA);
+				if (part_data) {
 					part_data[idx] = EraOperator::EraFromYear(yyyy);
 				}
 			}
@@ -564,10 +614,12 @@ struct DatePart {
 			// Week calculations
 			if (mask & DOW) {
 				auto isodow = Date::ExtractISODayOfTheWeek(input);
-				if (HasPartValue(part_values, DatePartSpecifier::DOW, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::DOW);
+				if (part_data) {
 					part_data[idx] = DayOfWeekOperator::DayOfWeekFromISO(isodow);
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::ISODOW, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::ISODOW);
+				if (part_data) {
 					part_data[idx] = isodow;
 				}
 			}
@@ -577,24 +629,29 @@ struct DatePart {
 				int32_t ww = 0;
 				int32_t iyyy = 0;
 				Date::ExtractISOYearWeek(input, iyyy, ww);
-				if (HasPartValue(part_values, DatePartSpecifier::WEEK, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::WEEK);
+				if (part_data) {
 					part_data[idx] = ww;
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::ISOYEAR, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::ISOYEAR);
+				if (part_data) {
 					part_data[idx] = iyyy;
 				}
-				if (HasPartValue(part_values, DatePartSpecifier::YEARWEEK, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::YEARWEEK);
+				if (part_data) {
 					part_data[idx] = YearWeekOperator::YearWeekFromParts(iyyy, ww);
 				}
 			}
 
 			if (mask & EPOCH) {
-				if (HasPartValue(part_values, DatePartSpecifier::EPOCH, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH);
+				if (part_data) {
 					part_data[idx] = Date::Epoch(input);
 				}
 			}
 			if (mask & DOY) {
-				if (HasPartValue(part_values, DatePartSpecifier::DOY, part_data)) {
+				part_data = HasPartValue(part_values, DatePartSpecifier::DOY);
+				if (part_data) {
 					part_data[idx] = Date::ExtractDayOfTheYear(input);
 				}
 			}
@@ -798,6 +855,51 @@ int64_t DatePart::YearWeekOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"yearweek\" not recognized");
 }
 
+template <>
+int64_t DatePart::EpochNanosecondsOperator::Operation(timestamp_t input) {
+	return Timestamp::GetEpochNanoSeconds(input);
+}
+
+template <>
+int64_t DatePart::EpochNanosecondsOperator::Operation(date_t input) {
+	return Date::EpochNanoseconds(input);
+}
+
+template <>
+int64_t DatePart::EpochNanosecondsOperator::Operation(interval_t input) {
+	return Interval::GetNanoseconds(input);
+}
+
+template <>
+int64_t DatePart::EpochMicrosecondsOperator::Operation(timestamp_t input) {
+	return Timestamp::GetEpochMicroSeconds(input);
+}
+
+template <>
+int64_t DatePart::EpochMicrosecondsOperator::Operation(date_t input) {
+	return Date::EpochMicroseconds(input);
+}
+
+template <>
+int64_t DatePart::EpochMicrosecondsOperator::Operation(interval_t input) {
+	return Interval::GetMicro(input);
+}
+
+template <>
+int64_t DatePart::EpochMillisOperator::Operation(timestamp_t input) {
+	return Timestamp::GetEpochMs(input);
+}
+
+template <>
+int64_t DatePart::EpochMillisOperator::Operation(date_t input) {
+	return Date::EpochMilliseconds(input);
+}
+
+template <>
+int64_t DatePart::EpochMillisOperator::Operation(interval_t input) {
+	return Interval::GetMilli(input);
+}
+
 template <>
 int64_t DatePart::MicrosecondsOperator::Operation(timestamp_t input) {
 	auto time = Timestamp::GetTime(input);
@@ -949,37 +1051,47 @@ void DatePart::StructOperator::Operation(int64_t **part_values, const dtime_t &i
 	int64_t *part_data;
 	if (mask & TIME) {
 		const auto micros = MicrosecondsOperator::Operation<dtime_t, int64_t>(input);
-		if (HasPartValue(part_values, DatePartSpecifier::MICROSECONDS, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::MICROSECONDS);
+		if (part_data) {
 			part_data[idx] = micros;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::MILLISECONDS, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::MILLISECONDS);
+		if (part_data) {
 			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::SECOND, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::SECOND);
+		if (part_data) {
 			part_data[idx] = micros / Interval::MICROS_PER_SEC;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::MINUTE, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::MINUTE);
+		if (part_data) {
 			part_data[idx] = MinutesOperator::Operation<dtime_t, int64_t>(input);
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::HOUR, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::HOUR);
+		if (part_data) {
 			part_data[idx] = HoursOperator::Operation<dtime_t, int64_t>(input);
 		}
 	}
 
 	if (mask & EPOCH) {
-		if (HasPartValue(part_values, DatePartSpecifier::EPOCH, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH);
+		if (part_data) {
 			part_data[idx] = EpochOperator::Operation<dtime_t, int64_t>(input);
+			;
 		}
 	}
 
 	if (mask & ZONE) {
-		if (HasPartValue(part_values, DatePartSpecifier::TIMEZONE, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE);
+		if (part_data) {
 			part_data[idx] = 0;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::TIMEZONE_HOUR, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE_HOUR);
+		if (part_data) {
 			part_data[idx] = 0;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::TIMEZONE_MINUTE, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE_MINUTE);
+		if (part_data) {
 			part_data[idx] = 0;
 		}
 	}
@@ -998,8 +1110,8 @@ void DatePart::StructOperator::Operation(int64_t **part_values, const timestamp_
 	Operation(part_values, t, idx, mask & ~EPOCH);
 
 	if (mask & EPOCH) {
-		int64_t *part_data;
-		if (HasPartValue(part_values, DatePartSpecifier::EPOCH, part_data)) {
+		auto part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH);
+		if (part_data) {
 			part_data[idx] = EpochOperator::Operation<timestamp_t, int64_t>(input);
 		}
 	}
@@ -1011,50 +1123,63 @@ void DatePart::StructOperator::Operation(int64_t **part_values, const interval_t
 	int64_t *part_data;
 	if (mask & YMD) {
 		const auto mm = input.months % Interval::MONTHS_PER_YEAR;
-		if (HasPartValue(part_values, DatePartSpecifier::YEAR, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::YEAR);
+		if (part_data) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_YEAR;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::MONTH, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::MONTH);
+		if (part_data) {
 			part_data[idx] = mm;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::DAY, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::DAY);
+		if (part_data) {
 			part_data[idx] = input.days;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::DECADE, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::DECADE);
+		if (part_data) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_DECADE;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::CENTURY, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::CENTURY);
+		if (part_data) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_CENTURY;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::MILLENNIUM, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::MILLENNIUM);
+		if (part_data) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_MILLENIUM;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::QUARTER, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::QUARTER);
+		if (part_data) {
 			part_data[idx] = mm / Interval::MONTHS_PER_QUARTER + 1;
 		}
 	}
 
 	if (mask & TIME) {
 		const auto micros = MicrosecondsOperator::Operation<interval_t, int64_t>(input);
-		if (HasPartValue(part_values, DatePartSpecifier::MICROSECONDS, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::MICROSECONDS);
+		if (part_data) {
 			part_data[idx] = micros;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::MILLISECONDS, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::MILLISECONDS);
+		if (part_data) {
 			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::SECOND, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::SECOND);
+		if (part_data) {
 			part_data[idx] = micros / Interval::MICROS_PER_SEC;
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::MINUTE, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::MINUTE);
+		if (part_data) {
 			part_data[idx] = MinutesOperator::Operation<interval_t, int64_t>(input);
 		}
-		if (HasPartValue(part_values, DatePartSpecifier::HOUR, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::HOUR);
+		if (part_data) {
 			part_data[idx] = HoursOperator::Operation<interval_t, int64_t>(input);
 		}
 	}
 
 	if (mask & EPOCH) {
-		if (HasPartValue(part_values, DatePartSpecifier::EPOCH, part_data)) {
+		part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH);
+		if (part_data) {
 			part_data[idx] = EpochOperator::Operation<interval_t, int64_t>(input);
 		}
 	}
@@ -1466,6 +1591,47 @@ ScalarFunctionSet EpochFun::GetFunctions() {
 	return GetTimePartFunction<DatePart::EpochOperator>();
 }
 
+ScalarFunctionSet EpochNanosecondsFun::GetFunctions() {
+	using OP = DatePart::EpochNanosecondsOperator;
+	auto operator_set = GetTimePartFunction<OP>();
+
+	//	TIMESTAMP WITH TIME ZONE has the same representation as TIMESTAMP so no need to defer to ICU
+	auto tstz_func = DatePart::UnaryFunction<timestamp_t, int64_t, OP>;
+	auto tstz_stats = OP::template PropagateStatistics<timestamp_t>;
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
+	return operator_set;
+}
+
+ScalarFunctionSet EpochMicrosecondsFun::GetFunctions() {
+	using OP = DatePart::EpochMicrosecondsOperator;
+	auto operator_set = GetTimePartFunction<OP>();
+
+	//	TIMESTAMP WITH TIME ZONE has the same representation as TIMESTAMP so no need to defer to ICU
+	auto tstz_func = DatePart::UnaryFunction<timestamp_t, int64_t, OP>;
+	auto tstz_stats = OP::template PropagateStatistics<timestamp_t>;
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
+	return operator_set;
+}
+
+ScalarFunctionSet EpochMsFun::GetFunctions() {
+	using OP = DatePart::EpochMillisOperator;
+	auto operator_set = GetTimePartFunction<OP>();
+
+	//	TIMESTAMP WITH TIME ZONE has the same representation as TIMESTAMP so no need to defer to ICU
+	auto tstz_func = DatePart::UnaryFunction<timestamp_t, int64_t, OP>;
+	auto tstz_stats = OP::template PropagateStatistics<timestamp_t>;
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
+
+	//	Legacy inverse BIGINT => TIMESTAMP
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, DatePart::EpochMillisOperator::Inverse));
+
+	return operator_set;
+}
+
 ScalarFunctionSet MicrosecondsFun::GetFunctions() {
 	return GetTimePartFunction<DatePart::MicrosecondsOperator>();
 }

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

@@ -20,23 +20,6 @@ static void EpochSecFunction(DataChunk &input, ExpressionState &state, Vector &r
 	UnaryExecutor::Execute<int64_t, timestamp_t, EpochSecOperator>(input.data[0], result, input.size());
 }
 
-struct EpochMillisOperator {
-	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		return Timestamp::FromEpochMs(input);
-	}
-};
-
-static void EpochMillisFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.ColumnCount() == 1);
-
-	UnaryExecutor::Execute<int64_t, timestamp_t, EpochMillisOperator>(input.data[0], result, input.size());
-}
-
-ScalarFunction EpochMsFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, EpochMillisFunction);
-}
-
 ScalarFunction ToTimestampFun::GetFunction() {
 	// to_timestamp is an alias from Postgres that converts the time in seconds to a timestamp
 	return ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, EpochSecFunction);

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

@@ -72,10 +72,21 @@ struct MakeTimestampOperator {
 		const auto t = MakeTimeOperator::Operation<HR, MN, SS, dtime_t>(hr, mn, ss);
 		return Timestamp::FromDatetime(d, t);
 	}
+
+	template <typename T, typename RESULT_TYPE>
+	static RESULT_TYPE Operation(T micros) {
+		return timestamp_t(micros);
+	}
 };
 
 template <typename T>
 static void ExecuteMakeTimestamp(DataChunk &input, ExpressionState &state, Vector &result) {
+	if (input.ColumnCount() == 1) {
+		auto func = MakeTimestampOperator::Operation<T, timestamp_t>;
+		UnaryExecutor::Execute<T, timestamp_t>(input.data[0], result, input.size(), func);
+		return;
+	}
+
 	D_ASSERT(input.ColumnCount() == 6);
 
 	auto func = MakeTimestampOperator::Operation<T, T, T, T, T, double, timestamp_t>;
@@ -99,10 +110,14 @@ ScalarFunction MakeTimeFun::GetFunction() {
 	                      ExecuteMakeTime<int64_t>);
 }
 
-ScalarFunction MakeTimestampFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT,
-	                       LogicalType::BIGINT, LogicalType::DOUBLE},
-	                      LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>);
+ScalarFunctionSet MakeTimestampFun::GetFunctions() {
+	ScalarFunctionSet operator_set("make_timestamp");
+	operator_set.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT,
+	                                         LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE},
+	                                        LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));
+	return operator_set;
 }
 
 } // namespace duckdb

package/src/duckdb/src/core_functions/scalar/list/list_aggregates.cpp

@@ -74,7 +74,8 @@ struct StateVector {
 		// destroy objects within the aggregate states
 		auto &aggr = aggr_expr->Cast<BoundAggregateExpression>();
 		if (aggr.function.destructor) {
-			AggregateInputData aggr_input_data(aggr.bind_info.get(), Allocator::DefaultAllocator());
+			ArenaAllocator allocator(Allocator::DefaultAllocator());
+			AggregateInputData aggr_input_data(aggr.bind_info.get(), allocator);
 			aggr.function.destructor(state_vector, aggr_input_data, count);
 		}
 	}
@@ -181,7 +182,8 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = func_expr.bind_info->Cast<ListAggregatesBindData>();
 	auto &aggr = info.aggr_expr->Cast<BoundAggregateExpression>();
-	AggregateInputData aggr_input_data(aggr.bind_info.get(), Allocator::DefaultAllocator());
+	ArenaAllocator allocator(Allocator::DefaultAllocator());
+	AggregateInputData aggr_input_data(aggr.bind_info.get(), allocator);
 
 	D_ASSERT(aggr.function.update);