duckdb 0.7.2-dev2867.0 → 0.7.2-dev2995.0

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

@@ -12,6 +12,7 @@
 #include "duckdb/parallel/base_pipeline_event.hpp"
 #include "duckdb/common/unordered_set.hpp"
 #include "duckdb/common/algorithm.hpp"
+#include "duckdb/parallel/interrupt.hpp"
 #include <functional>
 #include "duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp"
 
@@ -186,10 +187,10 @@ unique_ptr<LocalSinkState> PhysicalUngroupedAggregate::GetLocalSinkState(Executi
 	return make_uniq<UngroupedAggregateLocalState>(*this, children[0]->GetTypes(), gstate, context);
 }
 
-void PhysicalUngroupedAggregate::SinkDistinct(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                              DataChunk &input) const {
-	auto &sink = lstate.Cast<UngroupedAggregateLocalState>();
-	auto &global_sink = state.Cast<UngroupedAggregateGlobalState>();
+void PhysicalUngroupedAggregate::SinkDistinct(ExecutionContext &context, DataChunk &chunk,
+                                              OperatorSinkInput &input) const {
+	auto &sink = input.local_state.Cast<UngroupedAggregateLocalState>();
+	auto &global_sink = input.global_state.Cast<UngroupedAggregateGlobalState>();
 	D_ASSERT(distinct_data);
 	auto &distinct_state = *global_sink.distinct_state;
 	auto &distinct_info = *distinct_collection_info;
@@ -211,6 +212,7 @@ void PhysicalUngroupedAggregate::SinkDistinct(ExecutionContext &context, GlobalS
 		auto &radix_table = *distinct_data->radix_tables[table_idx];
 		auto &radix_global_sink = *distinct_state.radix_states[table_idx];
 		auto &radix_local_sink = *sink.radix_states[table_idx];
+		OperatorSinkInput sink_input {radix_global_sink, radix_local_sink, input.interrupt_state};
 
 		if (aggregate.filter) {
 			// The hashtable can apply a filter, but only on the payload
@@ -218,26 +220,25 @@ void PhysicalUngroupedAggregate::SinkDistinct(ExecutionContext &context, GlobalS
 
 			// Apply the filter before inserting into the hashtable
 			auto &filtered_data = sink.filter_set.GetFilterData(idx);
-			idx_t count = filtered_data.ApplyFilter(input);
+			idx_t count = filtered_data.ApplyFilter(chunk);
 			filtered_data.filtered_payload.SetCardinality(count);
 
-			radix_table.Sink(context, radix_global_sink, radix_local_sink, filtered_data.filtered_payload, empty_chunk,
-			                 distinct_filter);
+			radix_table.Sink(context, filtered_data.filtered_payload, sink_input, empty_chunk, distinct_filter);
 		} else {
-			radix_table.Sink(context, radix_global_sink, radix_local_sink, input, empty_chunk, distinct_filter);
+			radix_table.Sink(context, chunk, sink_input, empty_chunk, distinct_filter);
 		}
 	}
 }
 
-SinkResultType PhysicalUngroupedAggregate::Sink(ExecutionContext &context, GlobalSinkState &state,
-                                                LocalSinkState &lstate, DataChunk &input) const {
-	auto &sink = lstate.Cast<UngroupedAggregateLocalState>();
+SinkResultType PhysicalUngroupedAggregate::Sink(ExecutionContext &context, DataChunk &chunk,
+                                                OperatorSinkInput &input) const {
+	auto &sink = input.local_state.Cast<UngroupedAggregateLocalState>();
 
 	// perform the aggregation inside the local state
 	sink.Reset();
 
 	if (distinct_data) {
-		SinkDistinct(context, state, lstate, input);
+		SinkDistinct(context, chunk, input);
 	}
 
 	DataChunk &payload_chunk = sink.aggregate_input_chunk;
@@ -259,13 +260,13 @@ SinkResultType PhysicalUngroupedAggregate::Sink(ExecutionContext &context, Globa
 		// resolve the filter (if any)
 		if (aggregate.filter) {
 			auto &filtered_data = sink.filter_set.GetFilterData(aggr_idx);
-			auto count = filtered_data.ApplyFilter(input);
+			auto count = filtered_data.ApplyFilter(chunk);
 
 			sink.child_executor.SetChunk(filtered_data.filtered_payload);
 			payload_chunk.SetCardinality(count);
 		} else {
-			sink.child_executor.SetChunk(input);
-			payload_chunk.SetCardinality(input);
+			sink.child_executor.SetChunk(chunk);
+			payload_chunk.SetCardinality(chunk);
 		}
 
 #ifdef DEBUG
@@ -396,10 +397,17 @@ public:
 			//! Retrieve the stored data from the hashtable
 			while (true) {
 				output_chunk.Reset();
-				radix_table_p->GetData(temp_exec_context, output_chunk, *distinct_state.radix_states[table_idx],
-				                       *global_source_state, *local_source_state);
-				if (output_chunk.size() == 0) {
+
+				InterruptState interrupt_state;
+				OperatorSourceInput source_input {*global_source_state, *local_source_state, interrupt_state};
+				auto res = radix_table_p->GetData(temp_exec_context, output_chunk,
+				                                  *distinct_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 UngroupedDistinctAggregateFinalizeTask");
 				}
 
 				// We dont need to resolve the filter, we already did this in Sink
@@ -450,7 +458,7 @@ public:
 
 public:
 	void Schedule() override {
-		vector<unique_ptr<Task>> tasks;
+		vector<shared_ptr<Task>> tasks;
 		tasks.push_back(make_uniq<UngroupedDistinctAggregateFinalizeTask>(pipeline->executor, shared_from_this(),
 		                                                                  gstate, context, op));
 		D_ASSERT(!tasks.empty());
@@ -474,7 +482,7 @@ public:
 	void Schedule() override {
 		auto &distinct_state = *gstate.distinct_state;
 		auto &distinct_data = *op.distinct_data;
-		vector<unique_ptr<Task>> tasks;
+		vector<shared_ptr<Task>> tasks;
 		for (idx_t table_idx = 0; table_idx < distinct_data.radix_tables.size(); table_idx++) {
 			distinct_data.radix_tables[table_idx]->ScheduleTasks(pipeline->executor, shared_from_this(),
 			                                                     *distinct_state.radix_states[table_idx], tasks);
@@ -533,18 +541,6 @@ SinkFinalizeType PhysicalUngroupedAggregate::Finalize(Pipeline &pipeline, Event
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
-class UngroupedAggregateState : public GlobalSourceState {
-public:
-	UngroupedAggregateState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalUngroupedAggregate::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<UngroupedAggregateState>();
-}
-
 void VerifyNullHandling(DataChunk &chunk, AggregateState &state, const vector<unique_ptr<Expression>> &aggregates) {
 #ifdef DEBUG
 	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
@@ -559,14 +555,10 @@ void VerifyNullHandling(DataChunk &chunk, AggregateState &state, const vector<un
 #endif
 }
 
-void PhysicalUngroupedAggregate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                                         LocalSourceState &lstate) const {
+SourceResultType PhysicalUngroupedAggregate::GetData(ExecutionContext &context, DataChunk &chunk,
+                                                     OperatorSourceInput &input) const {
 	auto &gstate = sink_state->Cast<UngroupedAggregateGlobalState>();
-	auto &state = (UngroupedAggregateState &)gstate_p;
 	D_ASSERT(gstate.finished);
-	if (state.finished) {
-		return;
-	}
 
 	// initialize the result chunk with the aggregate values
 	chunk.SetCardinality(1);
@@ -578,7 +570,8 @@ void PhysicalUngroupedAggregate::GetData(ExecutionContext &context, DataChunk &c
 		aggregate.function.finalize(state_vector, aggr_input_data, chunk.data[aggr_idx], 1, 0);
 	}
 	VerifyNullHandling(chunk, gstate.state, aggregates);
-	state.finished = true;
+
+	return SourceResultType::FINISHED;
 }
 
 string PhysicalUngroupedAggregate::ParamsToString() const {

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

@@ -1036,11 +1036,10 @@ void WindowExecutor::Evaluate(idx_t row_idx, DataChunk &input_chunk, Vector &res
 //===--------------------------------------------------------------------===//
 // Sink
 //===--------------------------------------------------------------------===//
-SinkResultType PhysicalWindow::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
-                                    DataChunk &input) const {
-	auto &lstate = lstate_p.Cast<WindowLocalSinkState>();
+SinkResultType PhysicalWindow::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
+	auto &lstate = input.local_state.Cast<WindowLocalSinkState>();
 
-	lstate.Sink(input);
+	lstate.Sink(chunk);
 
 	return SinkResultType::NEED_MORE_INPUT;
 }
@@ -1339,10 +1338,10 @@ unique_ptr<GlobalSourceState> PhysicalWindow::GetGlobalSourceState(ClientContext
 	return make_uniq<WindowGlobalSourceState>(gsink);
 }
 
-void PhysicalWindow::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                             LocalSourceState &lstate_p) const {
-	auto &lsource = lstate_p.Cast<WindowLocalSourceState>();
-	auto &gsource = gstate_p.Cast<WindowGlobalSourceState>();
+SourceResultType PhysicalWindow::GetData(ExecutionContext &context, DataChunk &chunk,
+                                         OperatorSourceInput &input) const {
+	auto &lsource = input.local_state.Cast<WindowLocalSourceState>();
+	auto &gsource = input.global_state.Cast<WindowGlobalSourceState>();
 	auto &gsink = sink_state->Cast<WindowGlobalSinkState>();
 
 	auto &hash_groups = gsink.global_partition->hash_groups;
@@ -1357,7 +1356,7 @@ void PhysicalWindow::GetData(ExecutionContext &context, DataChunk &chunk, Global
 			lsource.hash_group.reset();
 			auto hash_bin = gsource.next_bin++;
 			if (hash_bin >= bin_count) {
-				return;
+				return chunk.size() > 0 ? SourceResultType::HAVE_MORE_OUTPUT : SourceResultType::FINISHED;
 			}
 
 			for (; hash_bin < hash_groups.size(); hash_bin = gsource.next_bin++) {
@@ -1370,6 +1369,8 @@ void PhysicalWindow::GetData(ExecutionContext &context, DataChunk &chunk, Global
 
 		lsource.Scan(chunk);
 	}
+
+	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
 }
 
 string PhysicalWindow::ParamsToString() const {

package/src/duckdb/src/execution/operator/helper/physical_batch_collector.cpp

@@ -29,10 +29,10 @@ public:
 	BatchedDataCollection data;
 };
 
-SinkResultType PhysicalBatchCollector::Sink(ExecutionContext &context, GlobalSinkState &gstate,
-                                            LocalSinkState &lstate_p, DataChunk &input) const {
-	auto &state = lstate_p.Cast<BatchCollectorLocalState>();
-	state.data.Append(input, state.batch_index);
+SinkResultType PhysicalBatchCollector::Sink(ExecutionContext &context, DataChunk &chunk,
+                                            OperatorSinkInput &input) const {
+	auto &state = input.local_state.Cast<BatchCollectorLocalState>();
+	state.data.Append(chunk, state.partition_info.batch_index.GetIndex());
 	return SinkResultType::NEED_MORE_INPUT;
 }
 

package/src/duckdb/src/execution/operator/helper/physical_explain_analyze.cpp

@@ -12,8 +12,8 @@ public:
 	string analyzed_plan;
 };
 
-SinkResultType PhysicalExplainAnalyze::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                            DataChunk &input) const {
+SinkResultType PhysicalExplainAnalyze::Sink(ExecutionContext &context, DataChunk &chunk,
+                                            OperatorSinkInput &input) const {
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -32,30 +32,15 @@ unique_ptr<GlobalSinkState> PhysicalExplainAnalyze::GetGlobalSinkState(ClientCon
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
-class ExplainAnalyzeState : public GlobalSourceState {
-public:
-	ExplainAnalyzeState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalExplainAnalyze::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<ExplainAnalyzeState>();
-}
-
-void PhysicalExplainAnalyze::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &source_state,
-                                     LocalSourceState &lstate) const {
-	auto &state = (ExplainAnalyzeState &)source_state;
+SourceResultType PhysicalExplainAnalyze::GetData(ExecutionContext &context, DataChunk &chunk,
+                                                 OperatorSourceInput &input) const {
 	auto &gstate = sink_state->Cast<ExplainAnalyzeStateGlobalState>();
-	if (state.finished) {
-		return;
-	}
+
 	chunk.SetValue(0, 0, Value("analyzed_plan"));
 	chunk.SetValue(1, 0, Value(gstate.analyzed_plan));
 	chunk.SetCardinality(1);
 
-	state.finished = true;
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/helper/physical_limit.cpp

@@ -92,25 +92,24 @@ bool PhysicalLimit::ComputeOffset(ExecutionContext &context, DataChunk &input, i
 	return true;
 }
 
-SinkResultType PhysicalLimit::Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
-                                   DataChunk &input) const {
+SinkResultType PhysicalLimit::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
 
-	D_ASSERT(input.size() > 0);
-	auto &state = lstate.Cast<LimitLocalState>();
+	D_ASSERT(chunk.size() > 0);
+	auto &state = input.local_state.Cast<LimitLocalState>();
 	auto &limit = state.limit;
 	auto &offset = state.offset;
 
 	idx_t max_element;
-	if (!ComputeOffset(context, input, limit, offset, state.current_offset, max_element, limit_expression.get(),
+	if (!ComputeOffset(context, chunk, limit, offset, state.current_offset, max_element, limit_expression.get(),
 	                   offset_expression.get())) {
 		return SinkResultType::FINISHED;
 	}
 	auto max_cardinality = max_element - state.current_offset;
-	if (max_cardinality < input.size()) {
-		input.SetCardinality(max_cardinality);
+	if (max_cardinality < chunk.size()) {
+		chunk.SetCardinality(max_cardinality);
 	}
-	state.data.Append(input, lstate.batch_index);
-	state.current_offset += input.size();
+	state.data.Append(chunk, state.partition_info.batch_index.GetIndex());
+	state.current_offset += chunk.size();
 	if (state.current_offset == max_element) {
 		return SinkResultType::FINISHED;
 	}
@@ -146,10 +145,9 @@ unique_ptr<GlobalSourceState> PhysicalLimit::GetGlobalSourceState(ClientContext
 	return make_uniq<LimitSourceState>();
 }
 
-void PhysicalLimit::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                            LocalSourceState &lstate) const {
+SourceResultType PhysicalLimit::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
 	auto &gstate = sink_state->Cast<LimitGlobalState>();
-	auto &state = gstate_p.Cast<LimitSourceState>();
+	auto &state = input.global_state.Cast<LimitSourceState>();
 	while (state.current_offset < gstate.limit + gstate.offset) {
 		if (!state.initialized) {
 			gstate.data.InitializeScan(state.scan_state);
@@ -157,12 +155,14 @@ void PhysicalLimit::GetData(ExecutionContext &context, DataChunk &chunk, GlobalS
 		}
 		gstate.data.Scan(state.scan_state, chunk);
 		if (chunk.size() == 0) {
-			break;
+			return SourceResultType::FINISHED;
 		}
 		if (HandleOffset(chunk, state.current_offset, gstate.offset, gstate.limit)) {
 			break;
 		}
 	}
+
+	return chunk.size() > 0 ? SourceResultType::HAVE_MORE_OUTPUT : SourceResultType::FINISHED;
 }
 
 bool PhysicalLimit::HandleOffset(DataChunk &input, idx_t &current_offset, idx_t offset, idx_t limit) {

package/src/duckdb/src/execution/operator/helper/physical_limit_percent.cpp

@@ -42,16 +42,15 @@ unique_ptr<GlobalSinkState> PhysicalLimitPercent::GetGlobalSinkState(ClientConte
 	return make_uniq<LimitPercentGlobalState>(context, *this);
 }
 
-SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
-                                          DataChunk &input) const {
-	D_ASSERT(input.size() > 0);
-	auto &state = gstate.Cast<LimitPercentGlobalState>();
+SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
+	D_ASSERT(chunk.size() > 0);
+	auto &state = input.global_state.Cast<LimitPercentGlobalState>();
 	auto &limit_percent = state.limit_percent;
 	auto &offset = state.offset;
 
 	// get the next chunk from the child
 	if (!state.is_limit_percent_delimited) {
-		Value val = PhysicalLimit::GetDelimiter(context, input, limit_expression.get());
+		Value val = PhysicalLimit::GetDelimiter(context, chunk, limit_expression.get());
 		if (!val.IsNull()) {
 			limit_percent = val.GetValue<double>();
 		}
@@ -61,7 +60,7 @@ SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, GlobalSinkS
 		state.is_limit_percent_delimited = true;
 	}
 	if (!state.is_offset_delimited) {
-		Value val = PhysicalLimit::GetDelimiter(context, input, offset_expression.get());
+		Value val = PhysicalLimit::GetDelimiter(context, chunk, offset_expression.get());
 		if (!val.IsNull()) {
 			offset = val.GetValue<idx_t>();
 		}
@@ -71,11 +70,11 @@ SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, GlobalSinkS
 		state.is_offset_delimited = true;
 	}
 
-	if (!PhysicalLimit::HandleOffset(input, state.current_offset, offset, DConstants::INVALID_INDEX)) {
+	if (!PhysicalLimit::HandleOffset(chunk, state.current_offset, offset, DConstants::INVALID_INDEX)) {
 		return SinkResultType::NEED_MORE_INPUT;
 	}
 
-	state.data.Append(input);
+	state.data.Append(chunk);
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -100,10 +99,10 @@ unique_ptr<GlobalSourceState> PhysicalLimitPercent::GetGlobalSourceState(ClientC
 	return make_uniq<LimitPercentOperatorState>(*this);
 }
 
-void PhysicalLimitPercent::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                                   LocalSourceState &lstate) const {
+SourceResultType PhysicalLimitPercent::GetData(ExecutionContext &context, DataChunk &chunk,
+                                               OperatorSourceInput &input) const {
 	auto &gstate = sink_state->Cast<LimitPercentGlobalState>();
-	auto &state = gstate_p.Cast<LimitPercentOperatorState>();
+	auto &state = input.global_state.Cast<LimitPercentOperatorState>();
 	auto &percent_limit = gstate.limit_percent;
 	auto &offset = gstate.offset;
 	auto &limit = state.limit;
@@ -124,18 +123,20 @@ void PhysicalLimitPercent::GetData(ExecutionContext &context, DataChunk &chunk,
 			limit = idx_t(limit_dbl);
 		}
 		if (limit == 0) {
-			return;
+			return SourceResultType::FINISHED;
 		}
 	}
 
 	if (current_offset >= limit) {
-		return;
+		return SourceResultType::FINISHED;
 	}
 	if (!gstate.data.Scan(state.scan_state, chunk)) {
-		return;
+		return SourceResultType::FINISHED;
 	}
 
 	PhysicalLimit::HandleOffset(chunk, current_offset, 0, limit);
+
+	return SourceResultType::HAVE_MORE_OUTPUT;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/helper/physical_load.cpp

@@ -3,13 +3,14 @@
 
 namespace duckdb {
 
-void PhysicalLoad::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                           LocalSourceState &lstate) const {
+SourceResultType PhysicalLoad::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
 	if (info->load_type == LoadType::INSTALL || info->load_type == LoadType::FORCE_INSTALL) {
 		ExtensionHelper::InstallExtension(context.client, info->filename, info->load_type == LoadType::FORCE_INSTALL);
 	} else {
 		ExtensionHelper::LoadExternalExtension(context.client, info->filename);
 	}
+
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/helper/physical_materialized_collector.cpp

@@ -25,10 +25,10 @@ public:
 	ColumnDataAppendState append_state;
 };
 
-SinkResultType PhysicalMaterializedCollector::Sink(ExecutionContext &context, GlobalSinkState &gstate_p,
-                                                   LocalSinkState &lstate_p, DataChunk &input) const {
-	auto &lstate = lstate_p.Cast<MaterializedCollectorLocalState>();
-	lstate.collection->Append(lstate.append_state, input);
+SinkResultType PhysicalMaterializedCollector::Sink(ExecutionContext &context, DataChunk &chunk,
+                                                   OperatorSinkInput &input) const {
+	auto &lstate = input.local_state.Cast<MaterializedCollectorLocalState>();
+	lstate.collection->Append(lstate.append_state, chunk);
 	return SinkResultType::NEED_MORE_INPUT;
 }
 

package/src/duckdb/src/execution/operator/helper/physical_pragma.cpp

@@ -2,11 +2,13 @@
 
 namespace duckdb {
 
-void PhysicalPragma::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                             LocalSourceState &lstate) const {
+SourceResultType PhysicalPragma::GetData(ExecutionContext &context, DataChunk &chunk,
+                                         OperatorSourceInput &input) const {
 	auto &client = context.client;
 	FunctionParameters parameters {info.parameters, info.named_parameters};
 	function.function(client, parameters);
+
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/helper/physical_prepare.cpp

@@ -3,12 +3,14 @@
 
 namespace duckdb {
 
-void PhysicalPrepare::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                              LocalSourceState &lstate) const {
+SourceResultType PhysicalPrepare::GetData(ExecutionContext &context, DataChunk &chunk,
+                                          OperatorSourceInput &input) const {
 	auto &client = context.client;
 
 	// store the prepared statement in the context
 	ClientData::Get(client).prepared_statements[name] = prepared;
+
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/helper/physical_reservoir_sample.cpp

@@ -34,9 +34,9 @@ unique_ptr<GlobalSinkState> PhysicalReservoirSample::GetGlobalSinkState(ClientCo
 	return make_uniq<SampleGlobalSinkState>(Allocator::Get(context), *options);
 }
 
-SinkResultType PhysicalReservoirSample::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                             DataChunk &input) const {
-	auto &gstate = state.Cast<SampleGlobalSinkState>();
+SinkResultType PhysicalReservoirSample::Sink(ExecutionContext &context, DataChunk &chunk,
+                                             OperatorSinkInput &input) const {
+	auto &gstate = input.global_state.Cast<SampleGlobalSinkState>();
 	if (!gstate.sample) {
 		return SinkResultType::FINISHED;
 	}
@@ -44,24 +44,26 @@ SinkResultType PhysicalReservoirSample::Sink(ExecutionContext &context, GlobalSi
 	// the algorithm is adopted from the paper Weighted random sampling with a reservoir by Pavlos S. Efraimidis et al.
 	// note that the original algorithm is about weighted sampling; this is a simplified approach for uniform sampling
 	lock_guard<mutex> glock(gstate.lock);
-	gstate.sample->AddToReservoir(input);
+	gstate.sample->AddToReservoir(chunk);
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
-void PhysicalReservoirSample::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                      LocalSourceState &lstate) const {
+SourceResultType PhysicalReservoirSample::GetData(ExecutionContext &context, DataChunk &chunk,
+                                                  OperatorSourceInput &input) const {
 	auto &sink = this->sink_state->Cast<SampleGlobalSinkState>();
 	if (!sink.sample) {
-		return;
+		return SourceResultType::FINISHED;
 	}
 	auto sample_chunk = sink.sample->GetChunk();
 	if (!sample_chunk) {
-		return;
+		return SourceResultType::FINISHED;
 	}
 	chunk.Move(*sample_chunk);
+
+	return SourceResultType::HAVE_MORE_OUTPUT;
 }
 
 string PhysicalReservoirSample::ParamsToString() const {

package/src/duckdb/src/execution/operator/helper/physical_reset.cpp

@@ -19,8 +19,7 @@ void PhysicalReset::ResetExtensionVariable(ExecutionContext &context, DBConfig &
 	}
 }
 
-void PhysicalReset::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                            LocalSourceState &lstate) const {
+SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
 	auto option = DBConfig::GetOptionByName(name);
 	if (!option) {
 		// check if this is an extra extension variable
@@ -30,7 +29,7 @@ void PhysicalReset::GetData(ExecutionContext &context, DataChunk &chunk, GlobalS
 			throw Catalog::UnrecognizedConfigurationError(context.client, name);
 		}
 		ResetExtensionVariable(context, config, entry->second);
-		return;
+		return SourceResultType::FINISHED;
 	}
 
 	// Transform scope
@@ -63,6 +62,8 @@ void PhysicalReset::GetData(ExecutionContext &context, DataChunk &chunk, GlobalS
 	default:
 		throw InternalException("Unsupported SetScope for variable");
 	}
+
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/helper/physical_set.cpp

@@ -22,8 +22,7 @@ void PhysicalSet::SetExtensionVariable(ClientContext &context, ExtensionOption &
 	}
 }
 
-void PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                          LocalSourceState &lstate) const {
+SourceResultType PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
 	auto option = DBConfig::GetOptionByName(name);
 	if (!option) {
 		// check if this is an extra extension variable
@@ -33,7 +32,7 @@ void PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSou
 			throw Catalog::UnrecognizedConfigurationError(context.client, name);
 		}
 		SetExtensionVariable(context.client, entry->second, name, scope, value);
-		return;
+		return SourceResultType::FINISHED;
 	}
 	SetScope variable_scope = scope;
 	if (variable_scope == SetScope::AUTOMATIC) {
@@ -45,7 +44,7 @@ void PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSou
 		}
 	}
 
-	Value input = value.CastAs(context.client, option->parameter_type);
+	Value input_val = value.CastAs(context.client, option->parameter_type);
 	switch (variable_scope) {
 	case SetScope::GLOBAL: {
 		if (!option->set_global) {
@@ -53,18 +52,20 @@ void PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSou
 		}
 		auto &db = DatabaseInstance::GetDatabase(context.client);
 		auto &config = DBConfig::GetConfig(context.client);
-		config.SetOption(&db, *option, input);
+		config.SetOption(&db, *option, input_val);
 		break;
 	}
 	case SetScope::SESSION:
 		if (!option->set_local) {
 			throw CatalogException("option \"%s\" cannot be set locally", name);
 		}
-		option->set_local(context.client, input);
+		option->set_local(context.client, input_val);
 		break;
 	default:
 		throw InternalException("Unsupported SetScope for variable");
 	}
+
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/helper/physical_transaction.cpp

@@ -4,8 +4,8 @@
 
 namespace duckdb {
 
-void PhysicalTransaction::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                  LocalSourceState &lstate) const {
+SourceResultType PhysicalTransaction::GetData(ExecutionContext &context, DataChunk &chunk,
+                                              OperatorSourceInput &input) const {
 	auto &client = context.client;
 
 	auto type = info->type;
@@ -48,6 +48,8 @@ void PhysicalTransaction::GetData(ExecutionContext &context, DataChunk &chunk, G
 	default:
 		throw NotImplementedException("Unrecognized transaction type!");
 	}
+
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb