duckdb 0.8.2-dev157.0 → 0.8.2-dev1573.0

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 EpochNsFun::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 EpochUsFun::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

@@ -1,7 +1,6 @@
 #include "duckdb/core_functions/scalar/date_functions.hpp"
-#include "duckdb/common/types/time.hpp"
-#include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/timestamp.hpp"
+
+#include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
 
@@ -9,37 +8,24 @@ namespace duckdb {
 
 struct EpochSecOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
-	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		return Timestamp::FromEpochSeconds(input);
+	static RESULT_TYPE Operation(INPUT_TYPE sec) {
+		int64_t result;
+		if (!TryCast::Operation(sec * Interval::MICROS_PER_SEC, result)) {
+			throw ConversionException("Could not convert epoch seconds to TIMESTAMP WITH TIME ZONE");
+		}
+		return timestamp_t(result);
 	}
 };
 
 static void EpochSecFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() == 1);
 
-	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);
+	UnaryExecutor::Execute<double, timestamp_t, EpochSecOperator>(input.data[0], result, input.size());
 }
 
 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);
+	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::TIMESTAMP_TZ, EpochSecFunction);
 }
 
 } // namespace duckdb

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);
 

package/src/duckdb/src/execution/aggregate_hashtable.cpp

@@ -58,9 +58,6 @@ GroupedAggregateHashTable::GroupedAggregateHashTable(ClientContext &context, All
 	data_collection = make_uniq<TupleDataCollection>(buffer_manager, layout);
 	data_collection->InitializeAppend(td_pin_state, TupleDataPinProperties::KEEP_EVERYTHING_PINNED);
 
-	hashes_hdl = buffer_manager.Allocate(Storage::BLOCK_SIZE);
-	hashes_hdl_ptr = hashes_hdl.Ptr();
-
 	switch (entry_type) {
 	case HtEntryType::HT_WIDTH_64: {
 		hash_prefix_shift = (HASH_WIDTH - sizeof(aggr_ht_entry_64::salt)) * 8;
@@ -100,7 +97,7 @@ void GroupedAggregateHashTable::Destroy() {
 	}
 
 	// There are aggregates with destructors: Call the destructor for each of the aggregates
-	RowOperationsState state(aggregate_allocator->GetAllocator());
+	RowOperationsState state(*aggregate_allocator);
 	TupleDataChunkIterator iterator(*data_collection, TupleDataPinProperties::DESTROY_AFTER_DONE, false);
 	auto &row_locations = iterator.GetChunkState().row_locations;
 	do {
@@ -182,10 +179,8 @@ void GroupedAggregateHashTable::Resize(idx_t size) {
 
 	bitmask = capacity - 1;
 	const auto byte_size = capacity * sizeof(ENTRY);
-	if (byte_size > (idx_t)Storage::BLOCK_SIZE) {
-		hashes_hdl = buffer_manager.Allocate(byte_size);
-		hashes_hdl_ptr = hashes_hdl.Ptr();
-	}
+	hashes_hdl = buffer_manager.GetBufferAllocator().Allocate(byte_size);
+	hashes_hdl_ptr = hashes_hdl.get();
 	memset(hashes_hdl_ptr, 0, byte_size);
 
 	if (Count() != 0) {
@@ -277,7 +272,7 @@ idx_t GroupedAggregateHashTable::AddChunk(AggregateHTAppendState &state, DataChu
 	auto &aggregates = layout.GetAggregates();
 	idx_t filter_idx = 0;
 	idx_t payload_idx = 0;
-	RowOperationsState row_state(aggregate_allocator->GetAllocator());
+	RowOperationsState row_state(*aggregate_allocator);
 	for (idx_t i = 0; i < aggregates.size(); i++) {
 		auto &aggr = aggregates[i];
 		if (filter_idx >= filter.size() || i < filter[filter_idx]) {
@@ -322,7 +317,7 @@ void GroupedAggregateHashTable::FetchAggregates(DataChunk &groups, DataChunk &re
 	Vector addresses(LogicalType::POINTER);
 	FindOrCreateGroups(append_state, groups, addresses);
 	// now fetch the aggregates
-	RowOperationsState row_state(aggregate_allocator->GetAllocator());
+	RowOperationsState row_state(*aggregate_allocator);
 	RowOperations::FinalizeStates(row_state, layout, addresses, result, 0);
 }
 
@@ -581,7 +576,7 @@ void GroupedAggregateHashTable::Combine(GroupedAggregateHashTable &other) {
 	}
 
 	FlushMoveState state(*other.data_collection);
-	RowOperationsState row_state(aggregate_allocator->GetAllocator());
+	RowOperationsState row_state(*aggregate_allocator);
 	while (state.Scan()) {
 		FindOrCreateGroups(state.append_state, state.groups, state.hashes, state.group_addresses, state.new_groups_sel);
 		RowOperations::CombineStates(row_state, layout, state.scan_state.chunk_state.row_locations,
@@ -591,14 +586,27 @@ void GroupedAggregateHashTable::Combine(GroupedAggregateHashTable &other) {
 	Verify();
 }
 
-void GroupedAggregateHashTable::Partition(vector<GroupedAggregateHashTable *> &partition_hts, idx_t radix_bits) {
+void GroupedAggregateHashTable::Append(GroupedAggregateHashTable &other) {
+	data_collection->Combine(other.GetDataCollection());
+
+	// Inherit ownership to all stored aggregate allocators
+	stored_allocators.emplace_back(other.aggregate_allocator);
+	for (const auto &stored_allocator : other.stored_allocators) {
+		stored_allocators.emplace_back(stored_allocator);
+	}
+}
+
+void GroupedAggregateHashTable::Partition(vector<GroupedAggregateHashTable *> &partition_hts, idx_t radix_bits,
+                                          bool sink_done) {
 	const auto num_partitions = RadixPartitioning::NumberOfPartitions(radix_bits);
 	D_ASSERT(partition_hts.size() == num_partitions);
 
 	// Partition the data
+	auto pin_properties =
+	    sink_done ? TupleDataPinProperties::UNPIN_AFTER_DONE : TupleDataPinProperties::KEEP_EVERYTHING_PINNED;
 	auto partitioned_data =
 	    make_uniq<RadixPartitionedTupleData>(buffer_manager, layout, radix_bits, layout.ColumnCount() - 1);
-	partitioned_data->Partition(*data_collection, TupleDataPinProperties::KEEP_EVERYTHING_PINNED);
+	partitioned_data->Partition(*data_collection, pin_properties);
 	D_ASSERT(partitioned_data->GetPartitions().size() == num_partitions);
 
 	// Move the partitioned data collections to the partitioned hash tables and initialize the 1st part of the HT
@@ -606,9 +614,17 @@ void GroupedAggregateHashTable::Partition(vector<GroupedAggregateHashTable *> &p
 	for (idx_t partition_idx = 0; partition_idx < num_partitions; partition_idx++) {
 		auto &partition_ht = *partition_hts[partition_idx];
 		partition_ht.data_collection = std::move(partitions[partition_idx]);
-		partition_ht.aggregate_allocator = aggregate_allocator;
-		partition_ht.InitializeFirstPart();
-		partition_ht.Verify();
+
+		// Inherit ownership to all stored aggregate allocators
+		partition_ht.stored_allocators.emplace_back(aggregate_allocator);
+		for (const auto &stored_allocator : stored_allocators) {
+			partition_ht.stored_allocators.emplace_back(stored_allocator);
+		}
+
+		if (!sink_done) {
+			partition_ht.InitializeFirstPart();
+			partition_ht.Verify();
+		}
 	}
 }
 
@@ -631,7 +647,7 @@ idx_t GroupedAggregateHashTable::Scan(TupleDataParallelScanState &gstate, TupleD
                                       DataChunk &result) {
 	data_collection->Scan(gstate, lstate, result);
 
-	RowOperationsState row_state(aggregate_allocator->GetAllocator());
+	RowOperationsState row_state(*aggregate_allocator);
 	const auto group_cols = layout.ColumnCount() - 1;
 	RowOperations::FinalizeStates(row_state, layout, lstate.chunk_state.row_locations, result, group_cols);
 
@@ -644,7 +660,7 @@ void GroupedAggregateHashTable::Finalize() {
 	}
 
 	// Early release hashes (not needed for partition/scan) and data collection (will be pinned again when scanning)
-	hashes_hdl.Destroy();
+	hashes_hdl.Reset();
 	data_collection->FinalizePinState(td_pin_state);
 	data_collection->Unpin();
 

package/src/duckdb/src/execution/expression_executor.cpp

@@ -126,7 +126,7 @@ bool ExpressionExecutor::TryEvaluateScalar(ClientContext &context, const Express
 		result = EvaluateScalar(context, expr);
 		return true;
 	} catch (InternalException &ex) {
-		throw ex;
+		throw;
 	} catch (...) {
 		return false;
 	}