duckdb 0.7.2-dev2867.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-dev2867.0",
+  "version": "0.7.2-dev2995.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

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

@@ -204,7 +204,11 @@ struct ICUDatePart : public ICUDateFunc {
 	}
 
 	static string_t MonthName(icu::Calendar *calendar, const uint64_t micros) {
-		return Date::MONTH_NAMES[ExtractMonth(calendar, micros) - 1];
+		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) {

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/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 {

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 {