duckdb 0.7.2-dev2820.0 → 0.7.2-dev2995.0

package/binding.gyp

@@ -136,6 +136,7 @@
                 "src/duckdb/src/verification/copied_statement_verifier.cpp", 
                 "src/duckdb/src/verification/deserialized_statement_verifier.cpp", 
                 "src/duckdb/src/verification/external_statement_verifier.cpp", 
+                "src/duckdb/src/verification/no_operator_caching_verifier.cpp", 
                 "src/duckdb/src/verification/parsed_statement_verifier.cpp", 
                 "src/duckdb/src/verification/prepared_statement_verifier.cpp", 
                 "src/duckdb/src/verification/statement_verifier.cpp", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev2820.0",
+  "version": "0.7.2-dev2995.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/icu/icu-datepart.cpp

@@ -203,6 +203,18 @@ struct ICUDatePart : public ICUDateFunc {
 		return Date::EpochToDate(ExtractEpoch(calendar, 0));
 	}
 
+	static string_t MonthName(icu::Calendar *calendar, const uint64_t micros) {
+		const auto mm = ExtractMonth(calendar, micros) - 1;
+		if (mm == 12) {
+			return "Undecember";
+		}
+		return Date::MONTH_NAMES[mm];
+	}
+
+	static string_t DayName(icu::Calendar *calendar, const uint64_t micros) {
+		return Date::DAY_NAMES[ExtractDayOfWeek(calendar, micros)];
+	}
+
 	template <typename RESULT_TYPE>
 	struct BindAdapterData : public BindData {
 		using result_t = RESULT_TYPE;
@@ -246,7 +258,7 @@ struct ICUDatePart : public ICUDateFunc {
 				                                                         return info.adapters[0](calendar, micros);
 			                                                         } else {
 				                                                         mask.SetInvalid(idx);
-				                                                         return RESULT_TYPE(0);
+				                                                         return RESULT_TYPE();
 			                                                         }
 		                                                         });
 	}
@@ -482,6 +494,44 @@ struct ICUDatePart : public ICUDateFunc {
 		CreateScalarFunctionInfo func_info(set);
 		catalog.AddFunction(context, func_info);
 	}
+
+	static unique_ptr<FunctionData> BindMonthName(ClientContext &context, ScalarFunction &bound_function,
+	                                              vector<unique_ptr<Expression>> &arguments) {
+		using data_t = BindAdapterData<string_t>;
+		return BindAdapter<data_t>(context, bound_function, arguments, MonthName);
+	}
+
+	template <typename INPUT_TYPE>
+	static ScalarFunction GetMonthNameFunction(const LogicalType &temporal_type) {
+		return ScalarFunction({temporal_type}, LogicalType::VARCHAR, UnaryTimestampFunction<INPUT_TYPE, string_t>,
+		                      BindMonthName);
+	}
+	static void AddMonthNameFunctions(const string &name, ClientContext &context) {
+		auto &catalog = Catalog::GetSystemCatalog(context);
+		ScalarFunctionSet set(name);
+		set.AddFunction(GetMonthNameFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
+		CreateScalarFunctionInfo func_info(set);
+		catalog.AddFunction(context, func_info);
+	}
+
+	static unique_ptr<FunctionData> BindDayName(ClientContext &context, ScalarFunction &bound_function,
+	                                            vector<unique_ptr<Expression>> &arguments) {
+		using data_t = BindAdapterData<string_t>;
+		return BindAdapter<data_t>(context, bound_function, arguments, DayName);
+	}
+
+	template <typename INPUT_TYPE>
+	static ScalarFunction GetDayNameFunction(const LogicalType &temporal_type) {
+		return ScalarFunction({temporal_type}, LogicalType::VARCHAR, UnaryTimestampFunction<INPUT_TYPE, string_t>,
+		                      BindDayName);
+	}
+	static void AddDayNameFunctions(const string &name, ClientContext &context) {
+		auto &catalog = Catalog::GetSystemCatalog(context);
+		ScalarFunctionSet set(name);
+		set.AddFunction(GetDayNameFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
+		CreateScalarFunctionInfo func_info(set);
+		catalog.AddFunction(context, func_info);
+	}
 };
 
 void RegisterICUDatePartFunctions(ClientContext &context) {
@@ -520,6 +570,10 @@ void RegisterICUDatePartFunctions(ClientContext &context) {
 	//  register the last_day function
 	ICUDatePart::AddLastDayFunctions("last_day", context);
 
+	// register the dayname/monthname functions
+	ICUDatePart::AddMonthNameFunctions("monthname", context);
+	ICUDatePart::AddDayNameFunctions("dayname", context);
+
 	// finally the actual date_part function
 	ICUDatePart::AddDatePartFunctions("date_part", context);
 	ICUDatePart::AddDatePartFunctions("datepart", context);

package/src/duckdb/extension/parquet/parquet-extension.cpp

@@ -369,7 +369,8 @@ public:
 				continue;
 			}
 			MultiFileReader::InitializeReader(*reader, bind_data.parquet_options.file_options, bind_data.reader_bind,
-			                                  bind_data.types, bind_data.names, input.column_ids, input.filters);
+			                                  bind_data.types, bind_data.names, input.column_ids, input.filters,
+			                                  bind_data.files[0]);
 		}
 
 		result->column_ids = input.column_ids;
@@ -561,9 +562,9 @@ public:
 				shared_ptr<ParquetReader> reader;
 				try {
 					reader = make_shared<ParquetReader>(context, file, pq_options);
-					MultiFileReader::InitializeReader(*reader, bind_data.parquet_options.file_options,
-					                                  bind_data.reader_bind, bind_data.types, bind_data.names,
-					                                  parallel_state.column_ids, parallel_state.filters);
+					MultiFileReader::InitializeReader(
+					    *reader, bind_data.parquet_options.file_options, bind_data.reader_bind, bind_data.types,
+					    bind_data.names, parallel_state.column_ids, parallel_state.filters, bind_data.files.front());
 				} catch (...) {
 					parallel_lock.lock();
 					parallel_state.error_opening_file = true;

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -51,16 +51,27 @@ vector<LogicalType> TableCatalogEntry::GetTypes() {
 	return types;
 }
 
+CreateTableInfo TableCatalogEntry::GetTableInfoForSerialization() const {
+	CreateTableInfo result;
+	result.catalog = catalog.GetName();
+	result.schema = schema.name;
+	result.table = name;
+	result.columns = columns.Copy();
+	result.constraints.reserve(constraints.size());
+	std::for_each(constraints.begin(), constraints.end(),
+	              [&result](const unique_ptr<Constraint> &c) { result.constraints.emplace_back(c->Copy()); });
+	return result;
+}
+
 void TableCatalogEntry::Serialize(Serializer &serializer) const {
 	D_ASSERT(!internal);
-
+	const auto info = GetTableInfoForSerialization();
 	FieldWriter writer(serializer);
-	auto catalog_name = catalog.GetName();
-	writer.WriteString(catalog_name);
-	writer.WriteString(schema.name);
-	writer.WriteString(name);
-	columns.Serialize(writer);
-	writer.WriteSerializableList(constraints);
+	writer.WriteString(info.catalog);
+	writer.WriteString(info.schema);
+	writer.WriteString(info.table);
+	info.columns.Serialize(writer);
+	writer.WriteSerializableList(info.constraints);
 	writer.Finalize();
 }
 

package/src/duckdb/src/catalog/default/default_functions.cpp

@@ -79,6 +79,8 @@ static DefaultMacro internal_macros[] = {
 	{"pg_catalog", "pg_ts_template_is_visible", {"template_oid", nullptr}, "true"},
 	{"pg_catalog", "pg_type_is_visible", {"type_oid", nullptr}, "true"},
 
+	{"pg_catalog", "pg_size_pretty", {"bytes", nullptr}, "format_bytes(bytes)"},
+
 	{DEFAULT_SCHEMA, "round_even", {"x", "n", nullptr}, "CASE ((abs(x) * power(10, n+1)) % 10) WHEN 5 THEN round(x/2, n) * 2 ELSE round(x, n) END"},
 	{DEFAULT_SCHEMA, "roundbankers", {"x", "n", nullptr}, "round_even(x, n)"},
 	{DEFAULT_SCHEMA, "nullif", {"a", "b", nullptr}, "CASE WHEN a=b THEN NULL ELSE a END"},

package/src/duckdb/src/common/arrow/arrow_appender.cpp

@@ -320,7 +320,7 @@ struct ArrowUUIDConverter {
 template <class SRC = string_t, class OP = ArrowVarcharConverter>
 struct ArrowVarcharData {
 	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
-		result.main_buffer.reserve((capacity + 1) * sizeof(uint32_t));
+		result.main_buffer.reserve((capacity + 1) * sizeof(uint64_t));
 		result.aux_buffer.reserve(capacity);
 	}
 
@@ -334,9 +334,9 @@ struct ArrowVarcharData {
 		auto validity_data = (uint8_t *)append_data.validity.data();
 
 		// resize the offset buffer - the offset buffer holds the offsets into the child array
-		append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(uint32_t) * (size + 1));
+		append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(uint64_t) * (size + 1));
 		auto data = (SRC *)format.data;
-		auto offset_data = (uint32_t *)append_data.main_buffer.data();
+		auto offset_data = (uint64_t *)append_data.main_buffer.data();
 		if (append_data.row_count == 0) {
 			// first entry
 			offset_data[0] = 0;

package/src/duckdb/src/common/arrow/arrow_converter.cpp

@@ -117,7 +117,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		break;
 	case LogicalTypeId::UUID:
 	case LogicalTypeId::VARCHAR:
-		child.format = "u";
+		child.format = "U";
 		break;
 	case LogicalTypeId::DATE:
 		child.format = "tdD";
@@ -171,7 +171,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 	}
 	case LogicalTypeId::BLOB:
 	case LogicalTypeId::BIT: {
-		child.format = "z";
+		child.format = "Z";
 		break;
 	}
 	case LogicalTypeId::LIST: {

package/src/duckdb/src/common/local_file_system.cpp

@@ -977,7 +977,6 @@ vector<string> LocalFileSystem::Glob(const string &path, FileOpener *opener) {
 		throw IOException("Cannot use multiple \'**\' in one path");
 	}
 
-	bool recursive_search = false;
 	for (idx_t i = absolute_path ? 1 : 0; i < splits.size(); i++) {
 		bool is_last_chunk = i + 1 == splits.size();
 		bool has_glob = HasGlob(splits[i]);
@@ -989,7 +988,7 @@ vector<string> LocalFileSystem::Glob(const string &path, FileOpener *opener) {
 			if (previous_directories.empty()) {
 				result.push_back(splits[i]);
 			} else {
-				if (recursive_search && is_last_chunk) {
+				if (is_last_chunk) {
 					for (auto &prev_directory : previous_directories) {
 						const string filename = JoinPath(prev_directory, splits[i]);
 						if (FileExists(filename) || DirectoryExists(filename)) {
@@ -1004,7 +1003,6 @@ vector<string> LocalFileSystem::Glob(const string &path, FileOpener *opener) {
 			}
 		} else {
 			if (IsCrawl(splits[i])) {
-				recursive_search = true;
 				if (!is_last_chunk) {
 					result = previous_directories;
 				}

package/src/duckdb/src/common/multi_file_reader.cpp

@@ -192,7 +192,7 @@ void MultiFileReader::FinalizeBind(const MultiFileReaderOptions &file_options, c
 void MultiFileReader::CreateNameMapping(const string &file_name, const vector<LogicalType> &local_types,
                                         const vector<string> &local_names, const vector<LogicalType> &global_types,
                                         const vector<string> &global_names, const vector<column_t> &global_column_ids,
-                                        MultiFileReaderData &reader_data) {
+                                        MultiFileReaderData &reader_data, const string &initial_file) {
 	D_ASSERT(global_types.size() == global_names.size());
 	D_ASSERT(local_types.size() == local_names.size());
 	// we have expected types: create a map of name -> column index
@@ -229,11 +229,12 @@ void MultiFileReader::CreateNameMapping(const string &file_name, const vector<Lo
 				}
 				candidate_names += local_name;
 			}
-			throw IOException(StringUtil::Format(
-			    "Failed to read file \"%s\": schema mismatch in glob: column \"%s\" was read from "
-			    "the original file, but could not be found in file \"%s\".\nCandidate names: %s\nIf you are trying to "
-			    "read files with different schemas, try setting union_by_name=True",
-			    file_name, global_name, file_name, candidate_names));
+			throw IOException(
+			    StringUtil::Format("Failed to read file \"%s\": schema mismatch in glob: column \"%s\" was read from "
+			                       "the original file \"%s\", but could not be found in file \"%s\".\nCandidate names: "
+			                       "%s\nIf you are trying to "
+			                       "read files with different schemas, try setting union_by_name=True",
+			                       file_name, global_name, initial_file, file_name, candidate_names));
 		}
 		// we found the column in the local file - check if the types are the same
 		auto local_id = entry->second;
@@ -254,8 +255,10 @@ void MultiFileReader::CreateNameMapping(const string &file_name, const vector<Lo
 void MultiFileReader::CreateMapping(const string &file_name, const vector<LogicalType> &local_types,
                                     const vector<string> &local_names, const vector<LogicalType> &global_types,
                                     const vector<string> &global_names, const vector<column_t> &global_column_ids,
-                                    optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data) {
-	CreateNameMapping(file_name, local_types, local_names, global_types, global_names, global_column_ids, reader_data);
+                                    optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data,
+                                    const string &initial_file) {
+	CreateNameMapping(file_name, local_types, local_names, global_types, global_names, global_column_ids, reader_data,
+	                  initial_file);
 	if (filters) {
 		reader_data.filter_map.resize(global_types.size());
 		for (idx_t c = 0; c < reader_data.column_mapping.size(); c++) {

package/src/duckdb/src/common/sort/partition_state.cpp

@@ -554,7 +554,7 @@ void PartitionMergeEvent::Schedule() {
 	auto &ts = TaskScheduler::GetScheduler(context);
 	idx_t num_threads = ts.NumberOfThreads();
 
-	vector<unique_ptr<Task>> merge_tasks;
+	vector<shared_ptr<Task>> merge_tasks;
 	for (idx_t tnum = 0; tnum < num_threads; tnum++) {
 		merge_tasks.emplace_back(make_uniq<PartitionMergeTask>(shared_from_this(), context, merge_states));
 	}

package/src/duckdb/src/common/string_util.cpp

@@ -163,6 +163,11 @@ string StringUtil::BytesToHumanReadableString(idx_t bytes) {
 	megabytes -= gigabytes * 1000;
 	auto terabytes = gigabytes / 1000;
 	gigabytes -= terabytes * 1000;
+	auto petabytes = terabytes / 1000;
+	terabytes -= petabytes * 1000;
+	if (petabytes > 0) {
+		return to_string(petabytes) + "." + to_string(terabytes / 100) + "PB";
+	}
 	if (terabytes > 0) {
 		return to_string(terabytes) + "." + to_string(gigabytes / 100) + "TB";
 	} else if (gigabytes > 0) {
@@ -172,7 +177,7 @@ string StringUtil::BytesToHumanReadableString(idx_t bytes) {
 	} else if (kilobytes > 0) {
 		return to_string(kilobytes) + "KB";
 	} else {
-		return to_string(bytes) + " bytes";
+		return to_string(bytes) + (bytes == 1 ? " byte" : " bytes");
 	}
 }
 

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/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/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/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"
@@ -250,10 +251,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];
@@ -280,6 +281,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 +292,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 +309,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 +362,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 +372,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 +456,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 +508,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 +583,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 +614,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 +661,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 +725,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 +879,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 +892,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 +912,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 {