duckdb 0.7.2-dev2867.0 → 0.7.2-dev3117.0

package/src/duckdb/src/common/types.cpp

@@ -28,7 +28,7 @@
 #include "duckdb/parser/parser.hpp"
 
 #include "duckdb/common/serializer/format_deserializer.hpp"
-#include "duckdb/common/serializer/enum_serializer.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/serializer/format_serializer.hpp"
 
 #include <cmath>
@@ -158,6 +158,11 @@ PhysicalType LogicalType::GetInternalType() {
 	}
 }
 
+// **DEPRECATED**: Use EnumUtil directly instead.
+string LogicalTypeIdToString(LogicalTypeId type) {
+	return EnumUtil::ToString(type);
+}
+
 constexpr const LogicalTypeId LogicalType::INVALID;
 constexpr const LogicalTypeId LogicalType::SQLNULL;
 constexpr const LogicalTypeId LogicalType::BOOLEAN;
@@ -331,10 +336,6 @@ bool TypeIsInteger(PhysicalType type) {
 	return (type >= PhysicalType::UINT8 && type <= PhysicalType::INT64) || type == PhysicalType::INT128;
 }
 
-string LogicalTypeIdToString(LogicalTypeId id) {
-	return EnumSerializer::EnumToString(id);
-}
-
 string LogicalType::ToString() const {
 	auto alias = GetAlias();
 	if (!alias.empty()) {
@@ -406,7 +407,7 @@ string LogicalType::ToString() const {
 		return AggregateStateType::GetTypeName(*this);
 	}
 	default:
-		return LogicalTypeIdToString(id_);
+		return EnumUtil::ToString(id_);
 	}
 }
 // LCOV_EXCL_STOP
@@ -1566,17 +1567,18 @@ void ExtraTypeInfo::Serialize(ExtraTypeInfo *info, FieldWriter &writer) {
 }
 void ExtraTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty("type", type);
+	// BREAKING: we used to write the alias last if there was additional type info, but now we write it second.
 	serializer.WriteProperty("alias", alias);
 }
 
 shared_ptr<ExtraTypeInfo> ExtraTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto type = deserializer.ReadProperty<ExtraTypeInfoType>("type");
+	auto alias = deserializer.ReadProperty<string>("alias");
+	// BREAKING: we used to read the alias last, but now we read it second.
 
 	shared_ptr<ExtraTypeInfo> result;
 	switch (type) {
 	case ExtraTypeInfoType::INVALID_TYPE_INFO: {
-		string alias;
-		deserializer.ReadOptionalProperty("alias", alias);
 		if (!alias.empty()) {
 			return make_shared<ExtraTypeInfo>(type, alias);
 		}
@@ -1620,11 +1622,10 @@ shared_ptr<ExtraTypeInfo> ExtraTypeInfo::FormatDeserialize(FormatDeserializer &d
 	case ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO:
 		result = AggregateStateTypeInfo::FormatDeserialize(deserializer);
 		break;
-
 	default:
 		throw InternalException("Unimplemented type info in ExtraTypeInfo::Deserialize");
 	}
-	deserializer.ReadOptionalPropertyOrDefault("alias", result->alias, string());
+	result->alias = alias;
 	return result;
 }
 

package/src/duckdb/src/common/vector_operations/is_distinct_from.cpp

@@ -900,15 +900,15 @@ idx_t VectorOperations::DistinctLessThan(Vector &left, Vector &right, const Sele
 // true := A < B with nulls being minimal
 idx_t VectorOperations::DistinctLessThanNullsFirst(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
                                                    SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctLessThanNullsFirst, duckdb::DistinctLessThan>(
-	    left, right, sel, count, true_sel, false_sel);
+	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThanNullsFirst, duckdb::DistinctGreaterThan>(
+	    right, left, sel, count, true_sel, false_sel);
 }
 
 // true := A <= B with nulls being maximal
 idx_t VectorOperations::DistinctLessThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
                                                SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThanEquals>(right, left, sel, count, true_sel,
-	                                                                           false_sel);
+	return count -
+	       TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThan>(left, right, sel, count, false_sel, true_sel);
 }
 
 // true := A != B with nulls being equal, inputs selected

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

@@ -148,6 +148,8 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION(ListFlattenFun),
 	DUCKDB_SCALAR_FUNCTION_SET(FloorFun),
 	DUCKDB_SCALAR_FUNCTION(FormatFun),
+	DUCKDB_SCALAR_FUNCTION_ALIAS(FormatreadabledecimalsizeFun),
+	DUCKDB_SCALAR_FUNCTION(FormatBytesFun),
 	DUCKDB_SCALAR_FUNCTION(FromBase64Fun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(FromBinaryFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(FromHexFun),

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

@@ -3,6 +3,7 @@
 #include "duckdb/common/enums/date_part_specifier.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
@@ -81,7 +82,7 @@ DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType
 		break;
 	}
 
-	throw NotImplementedException("\"%s\" units \"%s\" not recognized", LogicalTypeIdToString(type.id()), specifier);
+	throw NotImplementedException("\"%s\" units \"%s\" not recognized", EnumUtil::ToString(type.id()), specifier);
 }
 
 template <int64_t MIN, int64_t MAX>

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

@@ -1,11 +1,10 @@
 #include "duckdb/core_functions/scalar/list_functions.hpp"
-#include "duckdb/common/serializer/enum_serializer.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/types/chunk_collection.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/main/config.hpp"
-
 #include "duckdb/common/sort/sort.hpp"
 
 namespace duckdb {
@@ -251,7 +250,7 @@ static T GetOrder(ClientContext &context, Expression &expr) {
 	}
 	Value order_value = ExpressionExecutor::EvaluateScalar(context, expr);
 	auto order_name = StringUtil::Upper(order_value.ToString());
-	return EnumSerializer::StringToEnum<T>(order_name.c_str());
+	return EnumUtil::FromString<T>(order_name.c_str());
 }
 
 static unique_ptr<FunctionData> ListNormalSortBind(ClientContext &context, ScalarFunction &bound_function,

package/src/duckdb/src/core_functions/scalar/string/format_bytes.cpp

@@ -0,0 +1,29 @@
+#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/common/string_util.hpp"
+
+namespace duckdb {
+
+static void FormatBytesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	UnaryExecutor::Execute<int64_t, string_t>(args.data[0], result, args.size(), [&](int64_t bytes) {
+		bool is_negative = bytes < 0;
+		idx_t unsigned_bytes;
+		if (bytes < 0) {
+			if (bytes == NumericLimits<int64_t>::Minimum()) {
+				unsigned_bytes = idx_t(NumericLimits<int64_t>::Maximum()) + 1;
+			} else {
+				unsigned_bytes = idx_t(-bytes);
+			}
+		} else {
+			unsigned_bytes = idx_t(bytes);
+		}
+		return StringVector::AddString(result, (is_negative ? "-" : "") +
+		                                           StringUtil::BytesToHumanReadableString(unsigned_bytes));
+	});
+}
+
+ScalarFunction FormatBytesFun::GetFunction() {
+	return ScalarFunction({LogicalType::BIGINT}, LogicalType::VARCHAR, FormatBytesFunction);
+}
+
+} // namespace duckdb

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

@@ -236,7 +236,7 @@ void GroupedAggregateHashTable::Resize(idx_t size) {
 
 idx_t GroupedAggregateHashTable::AddChunk(AggregateHTAppendState &state, DataChunk &groups, DataChunk &payload,
                                           AggregateType filter) {
-	vector<idx_t> aggregate_filter;
+	unsafe_vector<idx_t> aggregate_filter;
 
 	auto &aggregates = layout.GetAggregates();
 	for (idx_t i = 0; i < aggregates.size(); i++) {
@@ -249,7 +249,7 @@ idx_t GroupedAggregateHashTable::AddChunk(AggregateHTAppendState &state, DataChu
 }
 
 idx_t GroupedAggregateHashTable::AddChunk(AggregateHTAppendState &state, DataChunk &groups, DataChunk &payload,
-                                          const vector<idx_t> &filter) {
+                                          const unsafe_vector<idx_t> &filter) {
 	Vector hashes(LogicalType::HASH);
 	groups.Hash(hashes);
 
@@ -257,7 +257,7 @@ idx_t GroupedAggregateHashTable::AddChunk(AggregateHTAppendState &state, DataChu
 }
 
 idx_t GroupedAggregateHashTable::AddChunk(AggregateHTAppendState &state, DataChunk &groups, Vector &group_hashes,
-                                          DataChunk &payload, const vector<idx_t> &filter) {
+                                          DataChunk &payload, const unsafe_vector<idx_t> &filter) {
 	D_ASSERT(!is_finalized);
 	if (groups.size() == 0) {
 		return 0;

package/src/duckdb/src/execution/index/art/art.cpp

@@ -879,7 +879,11 @@ string ART::GenerateConstraintErrorMessage(VerifyExistenceType verify_type, cons
 	case VerifyExistenceType::APPEND: {
 		// APPEND to PK/UNIQUE table, but node/key already exists in PK/UNIQUE table
 		string type = IsPrimary() ? "primary key" : "unique";
-		return StringUtil::Format("Duplicate key \"%s\" violates %s constraint", key_name, type);
+		return StringUtil::Format(
+		    "Duplicate key \"%s\" violates %s constraint. "
+		    "If this is an unexpected constraint violation please double "
+		    "check with the known index limitations section in our documentation (docs - sql - indexes).",
+		    key_name, type);
 	}
 	case VerifyExistenceType::APPEND_FK: {
 		// APPEND_FK to FK table, node/key does not exist in PK/UNIQUE table

package/src/duckdb/src/execution/operator/aggregate/distinct_aggregate_data.cpp

@@ -171,7 +171,7 @@ bool DistinctAggregateCollectionInfo::AnyDistinct() const {
 	return !indices.empty();
 }
 
-const vector<idx_t> &DistinctAggregateCollectionInfo::Indices() const {
+const unsafe_vector<idx_t> &DistinctAggregateCollectionInfo::Indices() const {
 	return this->indices;
 }
 

package/src/duckdb/src/execution/operator/aggregate/grouped_aggregate_data.cpp

@@ -12,7 +12,7 @@ const vector<vector<idx_t>> &GroupedAggregateData::GetGroupingFunctions() const
 
 void GroupedAggregateData::InitializeGroupby(vector<unique_ptr<Expression>> groups,
                                              vector<unique_ptr<Expression>> expressions,
-                                             vector<vector<idx_t>> grouping_functions) {
+                                             vector<unsafe_vector<idx_t>> grouping_functions) {
 	InitializeGroupbyGroups(std::move(groups));
 	vector<LogicalType> payload_types_filters;
 
@@ -86,7 +86,7 @@ void GroupedAggregateData::InitializeGroupbyGroups(vector<unique_ptr<Expression>
 	this->groups = std::move(groups);
 }
 
-void GroupedAggregateData::SetGroupingFunctions(vector<vector<idx_t>> &functions) {
+void GroupedAggregateData::SetGroupingFunctions(vector<unsafe_vector<idx_t>> &functions) {
 	grouping_functions.reserve(functions.size());
 	for (idx_t i = 0; i < functions.size(); i++) {
 		grouping_functions.push_back(std::move(functions[i]));

package/src/duckdb/src/execution/operator/aggregate/physical_hash_aggregate.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/aggregate_hashtable.hpp"
 #include "duckdb/main/client_context.hpp"
+#include "duckdb/parallel/interrupt.hpp"
 #include "duckdb/parallel/pipeline.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/parallel/thread_context.hpp"
@@ -116,7 +117,8 @@ PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<Logi
                                              vector<unique_ptr<Expression>> expressions,
                                              vector<unique_ptr<Expression>> groups_p,
                                              vector<GroupingSet> grouping_sets_p,
-                                             vector<vector<idx_t>> grouping_functions_p, idx_t estimated_cardinality)
+                                             vector<unsafe_vector<idx_t>> grouping_functions_p,
+                                             idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::HASH_GROUP_BY, std::move(types), estimated_cardinality),
       grouping_sets(std::move(grouping_sets_p)) {
 	// get a list of all aggregates to be computed
@@ -250,10 +252,10 @@ unique_ptr<LocalSinkState> PhysicalHashAggregate::GetLocalSinkState(ExecutionCon
 	return make_uniq<HashAggregateLocalState>(*this, context);
 }
 
-void PhysicalHashAggregate::SinkDistinctGrouping(ExecutionContext &context, GlobalSinkState &state,
-                                                 LocalSinkState &lstate, DataChunk &input, idx_t grouping_idx) const {
-	auto &sink = lstate.Cast<HashAggregateLocalState>();
-	auto &global_sink = state.Cast<HashAggregateGlobalState>();
+void PhysicalHashAggregate::SinkDistinctGrouping(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input,
+                                                 idx_t grouping_idx) const {
+	auto &sink = input.local_state.Cast<HashAggregateLocalState>();
+	auto &global_sink = input.global_state.Cast<HashAggregateGlobalState>();
 
 	auto &grouping_gstate = global_sink.grouping_states[grouping_idx];
 	auto &grouping_lstate = sink.grouping_states[grouping_idx];
@@ -265,7 +267,7 @@ void PhysicalHashAggregate::SinkDistinctGrouping(ExecutionContext &context, Glob
 	DataChunk empty_chunk;
 
 	// Create an empty filter for Sink, since we don't need to update any aggregate states here
-	vector<idx_t> empty_filter;
+	unsafe_vector<idx_t> empty_filter;
 
 	for (idx_t &idx : distinct_info.indices) {
 		auto &aggregate = grouped_aggregate_data.aggregates[idx]->Cast<BoundAggregateExpression>();
@@ -280,6 +282,9 @@ void PhysicalHashAggregate::SinkDistinctGrouping(ExecutionContext &context, Glob
 		auto &radix_global_sink = *distinct_state->radix_states[table_idx];
 		auto &radix_local_sink = *grouping_lstate.distinct_states[table_idx];
 
+		InterruptState interrupt_state;
+		OperatorSinkInput sink_input {radix_global_sink, radix_local_sink, interrupt_state};
+
 		if (aggregate.filter) {
 			DataChunk filter_chunk;
 			auto &filtered_data = sink.filter_set.GetFilterData(idx);
@@ -288,10 +293,10 @@ void PhysicalHashAggregate::SinkDistinctGrouping(ExecutionContext &context, Glob
 			// Add the filter Vector (BOOL)
 			auto it = filter_indexes.find(aggregate.filter.get());
 			D_ASSERT(it != filter_indexes.end());
-			D_ASSERT(it->second < input.data.size());
+			D_ASSERT(it->second < chunk.data.size());
 			auto &filter_bound_ref = aggregate.filter->Cast<BoundReferenceExpression>();
-			filter_chunk.data[filter_bound_ref.index].Reference(input.data[it->second]);
-			filter_chunk.SetCardinality(input.size());
+			filter_chunk.data[filter_bound_ref.index].Reference(chunk.data[it->second]);
+			filter_chunk.SetCardinality(chunk.size());
 
 			// We cant use the AggregateFilterData::ApplyFilter method, because the chunk we need to
 			// apply the filter to also has the groups, and the filtered_data.filtered_payload does not have those.
@@ -305,43 +310,42 @@ void PhysicalHashAggregate::SinkDistinctGrouping(ExecutionContext &context, Glob
 			// Because the 'input' chunk needs to be re-used after this, we need to create
 			// a duplicate of it, that we can apply the filter to
 			DataChunk filtered_input;
-			filtered_input.InitializeEmpty(input.GetTypes());
+			filtered_input.InitializeEmpty(chunk.GetTypes());
 
 			for (idx_t group_idx = 0; group_idx < grouped_aggregate_data.groups.size(); group_idx++) {
 				auto &group = grouped_aggregate_data.groups[group_idx];
 				auto &bound_ref = group->Cast<BoundReferenceExpression>();
-				filtered_input.data[bound_ref.index].Reference(input.data[bound_ref.index]);
+				filtered_input.data[bound_ref.index].Reference(chunk.data[bound_ref.index]);
 			}
 			for (idx_t child_idx = 0; child_idx < aggregate.children.size(); child_idx++) {
 				auto &child = aggregate.children[child_idx];
 				auto &bound_ref = child->Cast<BoundReferenceExpression>();
 
-				filtered_input.data[bound_ref.index].Reference(input.data[bound_ref.index]);
+				filtered_input.data[bound_ref.index].Reference(chunk.data[bound_ref.index]);
 			}
 			filtered_input.Slice(sel_vec, count);
 			filtered_input.SetCardinality(count);
 
-			radix_table.Sink(context, radix_global_sink, radix_local_sink, filtered_input, empty_chunk, empty_filter);
+			radix_table.Sink(context, filtered_input, sink_input, empty_chunk, empty_filter);
 		} else {
-			radix_table.Sink(context, radix_global_sink, radix_local_sink, input, empty_chunk, empty_filter);
+			radix_table.Sink(context, chunk, sink_input, empty_chunk, empty_filter);
 		}
 	}
 }
 
-void PhysicalHashAggregate::SinkDistinct(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                         DataChunk &input) const {
+void PhysicalHashAggregate::SinkDistinct(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
 	for (idx_t i = 0; i < groupings.size(); i++) {
-		SinkDistinctGrouping(context, state, lstate, input, i);
+		SinkDistinctGrouping(context, chunk, input, i);
 	}
 }
 
-SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                           DataChunk &input) const {
-	auto &llstate = lstate.Cast<HashAggregateLocalState>();
-	auto &gstate = state.Cast<HashAggregateGlobalState>();
+SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, DataChunk &chunk,
+                                           OperatorSinkInput &input) const {
+	auto &llstate = input.local_state.Cast<HashAggregateLocalState>();
+	auto &gstate = input.global_state.Cast<HashAggregateGlobalState>();
 
 	if (distinct_collection_info) {
-		SinkDistinct(context, state, lstate, input);
+		SinkDistinct(context, chunk, input);
 	}
 
 	if (CanSkipRegularSink()) {
@@ -359,8 +363,8 @@ SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, GlobalSink
 		for (auto &child_expr : aggr.children) {
 			D_ASSERT(child_expr->type == ExpressionType::BOUND_REF);
 			auto &bound_ref_expr = child_expr->Cast<BoundReferenceExpression>();
-			D_ASSERT(bound_ref_expr.index < input.data.size());
-			aggregate_input_chunk.data[aggregate_input_idx++].Reference(input.data[bound_ref_expr.index]);
+			D_ASSERT(bound_ref_expr.index < chunk.data.size());
+			aggregate_input_chunk.data[aggregate_input_idx++].Reference(chunk.data[bound_ref_expr.index]);
 		}
 	}
 	// Populate the filter vectors
@@ -369,23 +373,24 @@ SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, GlobalSink
 		if (aggr.filter) {
 			auto it = filter_indexes.find(aggr.filter.get());
 			D_ASSERT(it != filter_indexes.end());
-			D_ASSERT(it->second < input.data.size());
-			aggregate_input_chunk.data[aggregate_input_idx++].Reference(input.data[it->second]);
+			D_ASSERT(it->second < chunk.data.size());
+			aggregate_input_chunk.data[aggregate_input_idx++].Reference(chunk.data[it->second]);
 		}
 	}
 
-	aggregate_input_chunk.SetCardinality(input.size());
+	aggregate_input_chunk.SetCardinality(chunk.size());
 	aggregate_input_chunk.Verify();
 
 	// For every grouping set there is one radix_table
 	for (idx_t i = 0; i < groupings.size(); i++) {
 		auto &grouping_gstate = gstate.grouping_states[i];
 		auto &grouping_lstate = llstate.grouping_states[i];
+		InterruptState interrupt_state;
+		OperatorSinkInput sink_input {*grouping_gstate.table_state, *grouping_lstate.table_state, interrupt_state};
 
 		auto &grouping = groupings[i];
 		auto &table = grouping.table_data;
-		table.Sink(context, *grouping_gstate.table_state, *grouping_lstate.table_state, input, aggregate_input_chunk,
-		           non_distinct_filter);
+		table.Sink(context, chunk, sink_input, aggregate_input_chunk, non_distinct_filter);
 	}
 
 	return SinkResultType::NEED_MORE_INPUT;
@@ -452,7 +457,7 @@ public:
 
 public:
 	void Schedule() override {
-		vector<unique_ptr<Task>> tasks;
+		vector<shared_ptr<Task>> tasks;
 		for (idx_t i = 0; i < op.groupings.size(); i++) {
 			auto &grouping_gstate = gstate.grouping_states[i];
 
@@ -504,7 +509,7 @@ public:
 
 public:
 	void Schedule() override {
-		vector<unique_ptr<Task>> tasks;
+		vector<shared_ptr<Task>> tasks;
 		tasks.push_back(make_uniq<HashAggregateFinalizeTask>(*pipeline, shared_from_this(), gstate, context, op));
 		D_ASSERT(!tasks.empty());
 		SetTasks(std::move(tasks));
@@ -579,11 +584,18 @@ public:
 				output_chunk.Reset();
 				group_chunk.Reset();
 				aggregate_input_chunk.Reset();
-				radix_table_p->GetData(temp_exec_context, output_chunk, *state.radix_states[table_idx], *global_source,
-				                       *local_source);
 
-				if (output_chunk.size() == 0) {
+				InterruptState interrupt_state;
+				OperatorSourceInput source_input {*global_source, *local_source, interrupt_state};
+				auto res = radix_table_p->GetData(temp_exec_context, output_chunk, *state.radix_states[table_idx],
+				                                  source_input);
+
+				if (res == SourceResultType::FINISHED) {
+					D_ASSERT(output_chunk.size() == 0);
 					break;
+				} else if (res == SourceResultType::BLOCKED) {
+					throw InternalException(
+					    "Unexpected interrupt from radix table GetData in HashDistinctAggregateFinalizeTask");
 				}
 
 				auto &grouped_aggregate_data = *data.grouped_aggregate_data[table_idx];
@@ -603,8 +615,8 @@ public:
 				aggregate_input_chunk.SetCardinality(output_chunk);
 
 				// Sink it into the main ht
-				grouping_data.table_data.Sink(temp_exec_context, table_state, *temp_local_state, group_chunk,
-				                              aggregate_input_chunk, {i});
+				OperatorSinkInput sink_input {table_state, *temp_local_state, interrupt_state};
+				grouping_data.table_data.Sink(temp_exec_context, group_chunk, sink_input, aggregate_input_chunk, {i});
 			}
 		}
 		grouping_data.table_data.Combine(temp_exec_context, table_state, *temp_local_state);
@@ -650,7 +662,7 @@ public:
 	void Schedule() override {
 		global_sources = CreateGlobalSources();
 
-		vector<unique_ptr<Task>> tasks;
+		vector<shared_ptr<Task>> tasks;
 		auto &scheduler = TaskScheduler::GetScheduler(context);
 		auto number_of_threads = scheduler.NumberOfThreads();
 		tasks.reserve(number_of_threads);
@@ -714,7 +726,7 @@ public:
 
 public:
 	void Schedule() override {
-		vector<unique_ptr<Task>> tasks;
+		vector<shared_ptr<Task>> tasks;
 		for (idx_t i = 0; i < op.groupings.size(); i++) {
 			auto &grouping = op.groupings[i];
 			auto &distinct_data = *grouping.distinct_data;
@@ -868,11 +880,11 @@ unique_ptr<LocalSourceState> PhysicalHashAggregate::GetLocalSourceState(Executio
 	return make_uniq<PhysicalHashAggregateLocalSourceState>(context, *this);
 }
 
-void PhysicalHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                                    LocalSourceState &lstate_p) const {
+SourceResultType PhysicalHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk,
+                                                OperatorSourceInput &input) const {
 	auto &sink_gstate = sink_state->Cast<HashAggregateGlobalState>();
-	auto &gstate = gstate_p.Cast<PhysicalHashAggregateGlobalSourceState>();
-	auto &lstate = lstate_p.Cast<PhysicalHashAggregateLocalSourceState>();
+	auto &gstate = input.global_state.Cast<PhysicalHashAggregateGlobalSourceState>();
+	auto &lstate = input.local_state.Cast<PhysicalHashAggregateLocalSourceState>();
 	while (true) {
 		idx_t radix_idx = gstate.state_index;
 		if (radix_idx >= groupings.size()) {
@@ -881,11 +893,17 @@ void PhysicalHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk,
 		auto &grouping = groupings[radix_idx];
 		auto &radix_table = grouping.table_data;
 		auto &grouping_gstate = sink_gstate.grouping_states[radix_idx];
-		radix_table.GetData(context, chunk, *grouping_gstate.table_state, *gstate.radix_states[radix_idx],
-		                    *lstate.radix_states[radix_idx]);
+
+		InterruptState interrupt_state;
+		OperatorSourceInput source_input {*gstate.radix_states[radix_idx], *lstate.radix_states[radix_idx],
+		                                  interrupt_state};
+		auto res = radix_table.GetData(context, chunk, *grouping_gstate.table_state, source_input);
 		if (chunk.size() != 0) {
-			return;
+			return SourceResultType::HAVE_MORE_OUTPUT;
+		} else if (res == SourceResultType::BLOCKED) {
+			throw InternalException("Unexpectedly Blocked from radix_table");
 		}
+
 		// move to the next table
 		lock_guard<mutex> l(gstate.lock);
 		radix_idx++;
@@ -895,6 +913,8 @@ void PhysicalHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk,
 			gstate.state_index = radix_idx;
 		}
 	}
+
+	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
 }
 
 string PhysicalHashAggregate::ParamsToString() const {

package/src/duckdb/src/execution/operator/aggregate/physical_perfecthash_aggregate.cpp

@@ -114,9 +114,9 @@ unique_ptr<LocalSinkState> PhysicalPerfectHashAggregate::GetLocalSinkState(Execu
 	return make_uniq<PerfectHashAggregateLocalState>(*this, context);
 }
 
-SinkResultType PhysicalPerfectHashAggregate::Sink(ExecutionContext &context, GlobalSinkState &state,
-                                                  LocalSinkState &lstate_p, DataChunk &input) const {
-	auto &lstate = lstate_p.Cast<PerfectHashAggregateLocalState>();
+SinkResultType PhysicalPerfectHashAggregate::Sink(ExecutionContext &context, DataChunk &chunk,
+                                                  OperatorSinkInput &input) const {
+	auto &lstate = input.local_state.Cast<PerfectHashAggregateLocalState>();
 	DataChunk &group_chunk = lstate.group_chunk;
 	DataChunk &aggregate_input_chunk = lstate.aggregate_input_chunk;
 
@@ -124,7 +124,7 @@ SinkResultType PhysicalPerfectHashAggregate::Sink(ExecutionContext &context, Glo
 		auto &group = groups[group_idx];
 		D_ASSERT(group->type == ExpressionType::BOUND_REF);
 		auto &bound_ref_expr = group->Cast<BoundReferenceExpression>();
-		group_chunk.data[group_idx].Reference(input.data[bound_ref_expr.index]);
+		group_chunk.data[group_idx].Reference(chunk.data[bound_ref_expr.index]);
 	}
 	idx_t aggregate_input_idx = 0;
 	for (auto &aggregate : aggregates) {
@@ -132,7 +132,7 @@ SinkResultType PhysicalPerfectHashAggregate::Sink(ExecutionContext &context, Glo
 		for (auto &child_expr : aggr.children) {
 			D_ASSERT(child_expr->type == ExpressionType::BOUND_REF);
 			auto &bound_ref_expr = child_expr->Cast<BoundReferenceExpression>();
-			aggregate_input_chunk.data[aggregate_input_idx++].Reference(input.data[bound_ref_expr.index]);
+			aggregate_input_chunk.data[aggregate_input_idx++].Reference(chunk.data[bound_ref_expr.index]);
 		}
 	}
 	for (auto &aggregate : aggregates) {
@@ -140,13 +140,13 @@ SinkResultType PhysicalPerfectHashAggregate::Sink(ExecutionContext &context, Glo
 		if (aggr.filter) {
 			auto it = filter_indexes.find(aggr.filter.get());
 			D_ASSERT(it != filter_indexes.end());
-			aggregate_input_chunk.data[aggregate_input_idx++].Reference(input.data[it->second]);
+			aggregate_input_chunk.data[aggregate_input_idx++].Reference(chunk.data[it->second]);
 		}
 	}
 
-	group_chunk.SetCardinality(input.size());
+	group_chunk.SetCardinality(chunk.size());
 
-	aggregate_input_chunk.SetCardinality(input.size());
+	aggregate_input_chunk.SetCardinality(chunk.size());
 
 	group_chunk.Verify();
 	aggregate_input_chunk.Verify();
@@ -184,12 +184,18 @@ unique_ptr<GlobalSourceState> PhysicalPerfectHashAggregate::GetGlobalSourceState
 	return make_uniq<PerfectHashAggregateState>();
 }
 
-void PhysicalPerfectHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                                           LocalSourceState &lstate) const {
-	auto &state = (PerfectHashAggregateState &)gstate_p;
+SourceResultType PhysicalPerfectHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk,
+                                                       OperatorSourceInput &input) const {
+	auto &state = (PerfectHashAggregateState &)input.global_state;
 	auto &gstate = sink_state->Cast<PerfectHashAggregateGlobalState>();
 
 	gstate.ht->Scan(state.ht_scan_position, chunk);
+
+	if (chunk.size() > 0) {
+		return SourceResultType::HAVE_MORE_OUTPUT;
+	} else {
+		return SourceResultType::FINISHED;
+	}
 }
 
 string PhysicalPerfectHashAggregate::ParamsToString() const {