duckdb 0.8.2-dev1862.0 → 0.8.2-dev2044.0

package/src/duckdb/src/common/serializer/binary_serializer.cpp

@@ -129,7 +129,7 @@ void BinarySerializer::WriteValue(const string &value) {
 	auto len = value.length();
 	Write<uint32_t>((uint32_t)len);
 	if (len > 0) {
-		WriteData(value.c_str(), len);
+		WriteDataInternal(value.c_str(), len);
 	}
 }
 
@@ -137,7 +137,7 @@ void BinarySerializer::WriteValue(const string_t value) {
 	auto len = value.GetSize();
 	Write<uint32_t>((uint32_t)len);
 	if (len > 0) {
-		WriteData(value.GetDataUnsafe(), len);
+		WriteDataInternal(value.GetDataUnsafe(), len);
 	}
 }
 
@@ -145,7 +145,7 @@ void BinarySerializer::WriteValue(const char *value) {
 	auto len = strlen(value);
 	Write<uint32_t>((uint32_t)len);
 	if (len > 0) {
-		WriteData(value, len);
+		WriteDataInternal(value, len);
 	}
 }
 
@@ -154,7 +154,7 @@ void BinarySerializer::WriteValue(bool value) {
 }
 
 void BinarySerializer::WriteDataPtr(const_data_ptr_t ptr, idx_t count) {
-	WriteData(ptr, count);
+	WriteDataInternal(ptr, count);
 }
 
 } // namespace duckdb

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

@@ -6,6 +6,8 @@
 #include "duckdb/common/types/value_map.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -1057,4 +1059,45 @@ const vector<unique_ptr<ColumnDataCollectionSegment>> &ColumnDataCollection::Get
 	return segments;
 }
 
+void ColumnDataCollection::FormatSerialize(FormatSerializer &serializer) const {
+	vector<vector<Value>> values;
+	values.resize(ColumnCount());
+	for (auto &chunk : Chunks()) {
+		for (idx_t c = 0; c < chunk.ColumnCount(); c++) {
+			for (idx_t r = 0; r < chunk.size(); r++) {
+				values[c].push_back(chunk.GetValue(c, r));
+			}
+		}
+	}
+	serializer.WriteProperty("types", types);
+	serializer.WriteProperty("values", values);
+}
+
+unique_ptr<ColumnDataCollection> ColumnDataCollection::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto types = deserializer.ReadProperty<vector<LogicalType>>("types");
+	auto values = deserializer.ReadProperty<vector<vector<Value>>>("values");
+
+	auto collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
+	if (values.empty()) {
+		return collection;
+	}
+	DataChunk chunk;
+	chunk.Initialize(Allocator::DefaultAllocator(), types);
+
+	for (idx_t r = 0; r < values[0].size(); r++) {
+		for (idx_t c = 0; c < types.size(); c++) {
+			chunk.SetValue(c, chunk.size(), values[c][r]);
+		}
+		chunk.SetCardinality(chunk.size() + 1);
+		if (chunk.size() == STANDARD_VECTOR_SIZE) {
+			collection->Append(chunk);
+			chunk.Reset();
+		}
+	}
+	if (chunk.size() > 0) {
+		collection->Append(chunk);
+	}
+	return collection;
+}
+
 } // namespace duckdb

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

@@ -1,6 +1,7 @@
 #include "duckdb/common/types/hugeint.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/algorithm.hpp"
+#include "duckdb/common/hugeint.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/windows_undefs.hpp"
 #include "duckdb/common/types/value.hpp"
@@ -763,6 +764,45 @@ hugeint_t &hugeint_t::operator^=(const hugeint_t &rhs) {
 	return *this;
 }
 
+bool hugeint_t::operator!() const {
+	return *this == 0;
+}
+
+hugeint_t::operator bool() const {
+	return *this != 0;
+}
+
+template <class T>
+static T NarrowCast(const hugeint_t &input) {
+	// NarrowCast is supposed to truncate (take lower)
+	return static_cast<T>(input.lower);
+}
+
+hugeint_t::operator uint8_t() const {
+	return NarrowCast<uint8_t>(*this);
+}
+hugeint_t::operator uint16_t() const {
+	return NarrowCast<uint16_t>(*this);
+}
+hugeint_t::operator uint32_t() const {
+	return NarrowCast<uint32_t>(*this);
+}
+hugeint_t::operator uint64_t() const {
+	return NarrowCast<uint64_t>(*this);
+}
+hugeint_t::operator int8_t() const {
+	return NarrowCast<int8_t>(*this);
+}
+hugeint_t::operator int16_t() const {
+	return NarrowCast<int16_t>(*this);
+}
+hugeint_t::operator int32_t() const {
+	return NarrowCast<int32_t>(*this);
+}
+hugeint_t::operator int64_t() const {
+	return NarrowCast<int64_t>(*this);
+}
+
 string hugeint_t::ToString() const {
 	return Hugeint::ToString(*this);
 }

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

@@ -977,7 +977,7 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 	UnifiedVectorFormat vdata;
 	ToUnifiedFormat(count, vdata);
 
-	const auto all_valid = (count > 0) && !vdata.validity.AllValid();
+	const bool all_valid = (count > 0) && !vdata.validity.AllValid();
 	serializer.WriteProperty("all_valid", all_valid);
 	if (all_valid) {
 		ValidityMask flat_mask(count);

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

@@ -1108,18 +1108,6 @@ LogicalType LogicalType::Deserialize(Deserializer &source) {
 	return LogicalType(id, std::move(info));
 }
 
-void LogicalType::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("id", id_);
-	serializer.WriteOptionalProperty("type_info", type_info_.get());
-}
-
-LogicalType LogicalType::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto id = deserializer.ReadProperty<LogicalTypeId>("id");
-	auto info = deserializer.ReadOptionalProperty<shared_ptr<ExtraTypeInfo>>("type_info");
-
-	return LogicalType(id, std::move(info));
-}
-
 bool LogicalType::EqualTypeInfo(const LogicalType &rhs) const {
 	if (type_info_.get() == rhs.type_info_.get()) {
 		return true;

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

@@ -310,6 +310,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION_SET(TimezoneFun),
 	DUCKDB_SCALAR_FUNCTION_SET(TimezoneHourFun),
 	DUCKDB_SCALAR_FUNCTION_SET(TimezoneMinuteFun),
+	DUCKDB_SCALAR_FUNCTION_SET(ToBaseFun),
 	DUCKDB_SCALAR_FUNCTION(ToBase64Fun),
 	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ToBinaryFun),
 	DUCKDB_SCALAR_FUNCTION(ToDaysFun),

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

@@ -0,0 +1,66 @@
+#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+
+namespace duckdb {
+
+static const char alphabet[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+static unique_ptr<FunctionData> ToBaseBind(ClientContext &context, ScalarFunction &bound_function,
+                                           vector<unique_ptr<Expression>> &arguments) {
+	// If no min_length is specified, default to 0
+	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
+	if (arguments.size() == 2) {
+		arguments.push_back(make_uniq_base<Expression, BoundConstantExpression>(Value::INTEGER(0)));
+	}
+	return nullptr;
+}
+
+static void ToBaseFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &input = args.data[0];
+	auto &radix = args.data[1];
+	auto &min_length = args.data[2];
+	auto count = args.size();
+
+	TernaryExecutor::Execute<int64_t, int32_t, int32_t, string_t>(
+	    input, radix, min_length, result, count, [&](int64_t input, int32_t radix, int32_t min_length) {
+		    if (input < 0) {
+			    throw InvalidInputException("'to_base' number must be greater than or equal to 0");
+		    }
+		    if (radix < 2 || radix > 36) {
+			    throw InvalidInputException("'to_base' radix must be between 2 and 36");
+		    }
+		    if (min_length > 64 || min_length < 0) {
+			    throw InvalidInputException("'to_base' min_length must be between 0 and 64");
+		    }
+
+		    char buf[64];
+		    char *end = buf + sizeof(buf);
+		    char *ptr = end;
+		    do {
+			    *--ptr = alphabet[input % radix];
+			    input /= radix;
+		    } while (input > 0);
+
+		    auto length = end - ptr;
+		    while (length < min_length) {
+			    *--ptr = '0';
+			    length++;
+		    }
+
+		    return StringVector::AddString(result, ptr, end - ptr);
+	    });
+}
+
+ScalarFunctionSet ToBaseFun::GetFunctions() {
+	ScalarFunctionSet set("to_base");
+
+	set.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT, LogicalType::INTEGER}, LogicalType::VARCHAR, ToBaseFunction, ToBaseBind));
+	set.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::INTEGER, LogicalType::INTEGER},
+	                               LogicalType::VARCHAR, ToBaseFunction, ToBaseBind));
+
+	return set;
+}
+
+} // namespace duckdb

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

@@ -396,10 +396,10 @@ SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, DataChunk
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
-void PhysicalHashAggregate::CombineDistinct(ExecutionContext &context, GlobalSinkState &state,
-                                            LocalSinkState &lstate) const {
-	auto &global_sink = state.Cast<HashAggregateGlobalState>();
-	auto &sink = lstate.Cast<HashAggregateLocalState>();
+void PhysicalHashAggregate::CombineDistinct(ExecutionContext &context, OperatorSinkCombineInput &input) const {
+
+	auto &global_sink = input.global_state.Cast<HashAggregateGlobalState>();
+	auto &sink = input.local_state.Cast<HashAggregateLocalState>();
 
 	if (!distinct_collection_info) {
 		return;
@@ -425,14 +425,15 @@ void PhysicalHashAggregate::CombineDistinct(ExecutionContext &context, GlobalSin
 	}
 }
 
-void PhysicalHashAggregate::Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const {
-	auto &gstate = state.Cast<HashAggregateGlobalState>();
-	auto &llstate = lstate.Cast<HashAggregateLocalState>();
+SinkCombineResultType PhysicalHashAggregate::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
+	auto &gstate = input.global_state.Cast<HashAggregateGlobalState>();
+	auto &llstate = input.local_state.Cast<HashAggregateLocalState>();
 
-	CombineDistinct(context, state, lstate);
+	OperatorSinkCombineInput combine_distinct_input {gstate, llstate, input.interrupt_state};
+	CombineDistinct(context, combine_distinct_input);
 
 	if (CanSkipRegularSink()) {
-		return;
+		return SinkCombineResultType::FINISHED;
 	}
 	for (idx_t i = 0; i < groupings.size(); i++) {
 		auto &grouping_gstate = gstate.grouping_states[i];
@@ -442,6 +443,8 @@ void PhysicalHashAggregate::Combine(ExecutionContext &context, GlobalSinkState &
 		auto &table = grouping.table_data;
 		table.Combine(context, *grouping_gstate.table_state, *grouping_lstate.table_state);
 	}
+
+	return SinkCombineResultType::FINISHED;
 }
 
 //! REGULAR FINALIZE EVENT
@@ -818,8 +821,8 @@ SinkFinalizeType PhysicalHashAggregate::FinalizeInternal(Pipeline &pipeline, Eve
 }
 
 SinkFinalizeType PhysicalHashAggregate::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                 GlobalSinkState &gstate_p) const {
-	return FinalizeInternal(pipeline, event, context, gstate_p, true);
+                                                 OperatorSinkFinalizeInput &input) const {
+	return FinalizeInternal(pipeline, event, context, input.global_state, true);
 }
 
 //===--------------------------------------------------------------------===//

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

@@ -159,13 +159,15 @@ SinkResultType PhysicalPerfectHashAggregate::Sink(ExecutionContext &context, Dat
 //===--------------------------------------------------------------------===//
 // Combine
 //===--------------------------------------------------------------------===//
-void PhysicalPerfectHashAggregate::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
-                                           LocalSinkState &lstate_p) const {
-	auto &lstate = lstate_p.Cast<PerfectHashAggregateLocalState>();
-	auto &gstate = gstate_p.Cast<PerfectHashAggregateGlobalState>();
+SinkCombineResultType PhysicalPerfectHashAggregate::Combine(ExecutionContext &context,
+                                                            OperatorSinkCombineInput &input) const {
+	auto &lstate = input.local_state.Cast<PerfectHashAggregateLocalState>();
+	auto &gstate = input.global_state.Cast<PerfectHashAggregateGlobalState>();
 
 	lock_guard<mutex> l(gstate.lock);
 	gstate.ht->Combine(*lstate.ht);
+
+	return SinkCombineResultType::FINISHED;
 }
 
 //===--------------------------------------------------------------------===//

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

@@ -299,10 +299,9 @@ SinkResultType PhysicalUngroupedAggregate::Sink(ExecutionContext &context, DataC
 // Finalize
 //===--------------------------------------------------------------------===//
 
-void PhysicalUngroupedAggregate::CombineDistinct(ExecutionContext &context, GlobalSinkState &state,
-                                                 LocalSinkState &lstate) const {
-	auto &global_sink = state.Cast<UngroupedAggregateGlobalState>();
-	auto &source = lstate.Cast<UngroupedAggregateLocalState>();
+void PhysicalUngroupedAggregate::CombineDistinct(ExecutionContext &context, OperatorSinkCombineInput &input) const {
+	auto &global_sink = input.global_state.Cast<UngroupedAggregateGlobalState>();
+	auto &source = input.local_state.Cast<UngroupedAggregateLocalState>();
 
 	if (!distinct_data) {
 		return;
@@ -319,10 +318,10 @@ void PhysicalUngroupedAggregate::CombineDistinct(ExecutionContext &context, Glob
 	}
 }
 
-void PhysicalUngroupedAggregate::Combine(ExecutionContext &context, GlobalSinkState &state,
-                                         LocalSinkState &lstate) const {
-	auto &gstate = state.Cast<UngroupedAggregateGlobalState>();
-	auto &source = lstate.Cast<UngroupedAggregateLocalState>();
+SinkCombineResultType PhysicalUngroupedAggregate::Combine(ExecutionContext &context,
+                                                          OperatorSinkCombineInput &input) const {
+	auto &gstate = input.global_state.Cast<UngroupedAggregateGlobalState>();
+	auto &source = input.local_state.Cast<UngroupedAggregateLocalState>();
 	D_ASSERT(!gstate.finished);
 
 	// finalize: combine the local state into the global state
@@ -330,7 +329,8 @@ void PhysicalUngroupedAggregate::Combine(ExecutionContext &context, GlobalSinkSt
 	// use the combine method to combine the partial aggregates
 	lock_guard<mutex> glock(gstate.lock);
 
-	CombineDistinct(context, state, lstate);
+	OperatorSinkCombineInput distinct_input {gstate, source, input.interrupt_state};
+	CombineDistinct(context, distinct_input);
 
 	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
 		auto &aggregate = aggregates[aggr_idx]->Cast<BoundAggregateExpression>();
@@ -353,6 +353,8 @@ void PhysicalUngroupedAggregate::Combine(ExecutionContext &context, GlobalSinkSt
 	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(*this, source.child_executor, "child_executor", 0);
 	client_profiler.Flush(context.thread.profiler);
+
+	return SinkCombineResultType::FINISHED;
 }
 
 class UngroupedDistinctAggregateFinalizeTask : public ExecutorTask {
@@ -536,11 +538,11 @@ SinkFinalizeType PhysicalUngroupedAggregate::FinalizeDistinct(Pipeline &pipeline
 }
 
 SinkFinalizeType PhysicalUngroupedAggregate::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                      GlobalSinkState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<UngroupedAggregateGlobalState>();
+                                                      OperatorSinkFinalizeInput &input) const {
+	auto &gstate = input.global_state.Cast<UngroupedAggregateGlobalState>();
 
 	if (distinct_data) {
-		return FinalizeDistinct(pipeline, event, context, gstate_p);
+		return FinalizeDistinct(pipeline, event, context, input.global_state);
 	}
 
 	D_ASSERT(!gstate.finished);

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

@@ -124,9 +124,11 @@ SinkResultType PhysicalWindow::Sink(ExecutionContext &context, DataChunk &chunk,
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
-void PhysicalWindow::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &lstate = lstate_p.Cast<WindowLocalSinkState>();
+SinkCombineResultType PhysicalWindow::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
+	auto &lstate = input.local_state.Cast<WindowLocalSinkState>();
 	lstate.Combine();
+
+	return SinkCombineResultType::FINISHED;
 }
 
 unique_ptr<LocalSinkState> PhysicalWindow::GetLocalSinkState(ExecutionContext &context) const {
@@ -139,8 +141,8 @@ unique_ptr<GlobalSinkState> PhysicalWindow::GetGlobalSinkState(ClientContext &co
 }
 
 SinkFinalizeType PhysicalWindow::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                          GlobalSinkState &gstate_p) const {
-	auto &state = gstate_p.Cast<WindowGlobalSinkState>();
+                                          OperatorSinkFinalizeInput &input) const {
+	auto &state = input.global_state.Cast<WindowGlobalSinkState>();
 
 	//	Did we get any data?
 	if (!state.global_partition->count) {

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

@@ -37,18 +37,20 @@ SinkResultType PhysicalBatchCollector::Sink(ExecutionContext &context, DataChunk
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
-void PhysicalBatchCollector::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
-                                     LocalSinkState &lstate_p) const {
-	auto &gstate = gstate_p.Cast<BatchCollectorGlobalState>();
-	auto &state = lstate_p.Cast<BatchCollectorLocalState>();
+SinkCombineResultType PhysicalBatchCollector::Combine(ExecutionContext &context,
+                                                      OperatorSinkCombineInput &input) const {
+	auto &gstate = input.global_state.Cast<BatchCollectorGlobalState>();
+	auto &state = input.local_state.Cast<BatchCollectorLocalState>();
 
 	lock_guard<mutex> lock(gstate.glock);
 	gstate.data.Merge(state.data);
+
+	return SinkCombineResultType::FINISHED;
 }
 
 SinkFinalizeType PhysicalBatchCollector::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                  GlobalSinkState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<BatchCollectorGlobalState>();
+                                                  OperatorSinkFinalizeInput &input) const {
+	auto &gstate = input.global_state.Cast<BatchCollectorGlobalState>();
 	auto collection = gstate.data.FetchCollection();
 	D_ASSERT(collection);
 	auto result = make_uniq<MaterializedQueryResult>(statement_type, properties, names, std::move(collection),

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

@@ -18,8 +18,8 @@ SinkResultType PhysicalExplainAnalyze::Sink(ExecutionContext &context, DataChunk
 }
 
 SinkFinalizeType PhysicalExplainAnalyze::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                  GlobalSinkState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<ExplainAnalyzeStateGlobalState>();
+                                                  OperatorSinkFinalizeInput &input) const {
+	auto &gstate = input.global_state.Cast<ExplainAnalyzeStateGlobalState>();
 	auto &profiler = QueryProfiler::Get(context);
 	gstate.analyzed_plan = profiler.ToString();
 	return SinkFinalizeType::READY;

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

@@ -116,14 +116,16 @@ SinkResultType PhysicalLimit::Sink(ExecutionContext &context, DataChunk &chunk,
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
-void PhysicalLimit::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = gstate_p.Cast<LimitGlobalState>();
-	auto &state = lstate_p.Cast<LimitLocalState>();
+SinkCombineResultType PhysicalLimit::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
+	auto &gstate = input.global_state.Cast<LimitGlobalState>();
+	auto &state = input.local_state.Cast<LimitLocalState>();
 
 	lock_guard<mutex> lock(gstate.glock);
 	gstate.limit = state.limit;
 	gstate.offset = state.offset;
 	gstate.data.Merge(state.data);
+
+	return SinkCombineResultType::FINISHED;
 }
 
 //===--------------------------------------------------------------------===//

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

@@ -32,12 +32,12 @@ SinkResultType PhysicalMaterializedCollector::Sink(ExecutionContext &context, Da
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
-void PhysicalMaterializedCollector::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
-                                            LocalSinkState &lstate_p) const {
-	auto &gstate = gstate_p.Cast<MaterializedCollectorGlobalState>();
-	auto &lstate = lstate_p.Cast<MaterializedCollectorLocalState>();
+SinkCombineResultType PhysicalMaterializedCollector::Combine(ExecutionContext &context,
+                                                             OperatorSinkCombineInput &input) const {
+	auto &gstate = input.global_state.Cast<MaterializedCollectorGlobalState>();
+	auto &lstate = input.local_state.Cast<MaterializedCollectorLocalState>();
 	if (lstate.collection->Count() == 0) {
-		return;
+		return SinkCombineResultType::FINISHED;
 	}
 
 	lock_guard<mutex> l(gstate.glock);
@@ -46,6 +46,8 @@ void PhysicalMaterializedCollector::Combine(ExecutionContext &context, GlobalSin
 	} else {
 		gstate.collection->Combine(*lstate.collection);
 	}
+
+	return SinkCombineResultType::FINISHED;
 }
 
 unique_ptr<GlobalSinkState> PhysicalMaterializedCollector::GetGlobalSinkState(ClientContext &context) const {

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

@@ -57,20 +57,22 @@ SinkResultType PhysicalVacuum::Sink(ExecutionContext &context, DataChunk &chunk,
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
-void PhysicalVacuum::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = gstate_p.Cast<VacuumGlobalSinkState>();
-	auto &lstate = lstate_p.Cast<VacuumLocalSinkState>();
+SinkCombineResultType PhysicalVacuum::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
+	auto &gstate = input.global_state.Cast<VacuumGlobalSinkState>();
+	auto &lstate = input.local_state.Cast<VacuumLocalSinkState>();
 
 	lock_guard<mutex> lock(gstate.stats_lock);
 	D_ASSERT(gstate.column_distinct_stats.size() == lstate.column_distinct_stats.size());
 	for (idx_t col_idx = 0; col_idx < gstate.column_distinct_stats.size(); col_idx++) {
 		gstate.column_distinct_stats[col_idx]->Merge(*lstate.column_distinct_stats[col_idx]);
 	}
+
+	return SinkCombineResultType::FINISHED;
 }
 
 SinkFinalizeType PhysicalVacuum::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                          GlobalSinkState &gstate) const {
-	auto &sink = gstate.Cast<VacuumGlobalSinkState>();
+                                          OperatorSinkFinalizeInput &input) const {
+	auto &sink = input.global_state.Cast<VacuumGlobalSinkState>();
 
 	auto table = info->table;
 	for (idx_t col_idx = 0; col_idx < sink.column_distinct_stats.size(); col_idx++) {

package/src/duckdb/src/execution/operator/join/physical_asof_join.cpp

@@ -143,17 +143,18 @@ SinkResultType PhysicalAsOfJoin::Sink(ExecutionContext &context, DataChunk &chun
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
-void PhysicalAsOfJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &lstate = lstate_p.Cast<AsOfLocalSinkState>();
+SinkCombineResultType PhysicalAsOfJoin::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
+	auto &lstate = input.local_state.Cast<AsOfLocalSinkState>();
 	lstate.Combine();
+	return SinkCombineResultType::FINISHED;
 }
 
 //===--------------------------------------------------------------------===//
 // Finalize
 //===--------------------------------------------------------------------===//
 SinkFinalizeType PhysicalAsOfJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                            GlobalSinkState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<AsOfGlobalSinkState>();
+                                            OperatorSinkFinalizeInput &input) const {
+	auto &gstate = input.global_state.Cast<AsOfGlobalSinkState>();
 
 	// The data is all in so we can initialise the left partitioning.
 	const vector<unique_ptr<BaseStatistics>> partitions_stats;

package/src/duckdb/src/execution/operator/join/physical_blockwise_nl_join.cpp

@@ -62,8 +62,8 @@ SinkResultType PhysicalBlockwiseNLJoin::Sink(ExecutionContext &context, DataChun
 // Finalize
 //===--------------------------------------------------------------------===//
 SinkFinalizeType PhysicalBlockwiseNLJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                                   GlobalSinkState &gstate_p) const {
-	auto &gstate = gstate_p.Cast<BlockwiseNLJoinGlobalState>();
+                                                   OperatorSinkFinalizeInput &input) const {
+	auto &gstate = input.global_state.Cast<BlockwiseNLJoinGlobalState>();
 	gstate.right_outer.Initialize(gstate.right_chunks.Count());
 
 	if (gstate.right_chunks.Count() == 0 && EmptyResultIfRHSIsEmpty()) {

package/src/duckdb/src/execution/operator/join/physical_delim_join.cpp

@@ -98,18 +98,25 @@ SinkResultType PhysicalDelimJoin::Sink(ExecutionContext &context, DataChunk &chu
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
-void PhysicalDelimJoin::Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p) const {
-	auto &lstate = lstate_p.Cast<DelimJoinLocalState>();
-	auto &gstate = state.Cast<DelimJoinGlobalState>();
+SinkCombineResultType PhysicalDelimJoin::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
+	auto &lstate = input.local_state.Cast<DelimJoinLocalState>();
+	auto &gstate = input.global_state.Cast<DelimJoinGlobalState>();
 	gstate.Merge(lstate.lhs_data);
-	distinct->Combine(context, *distinct->sink_state, *lstate.distinct_state);
+
+	OperatorSinkCombineInput distinct_combine_input {*distinct->sink_state, *lstate.distinct_state,
+	                                                 input.interrupt_state};
+	distinct->Combine(context, distinct_combine_input);
+
+	return SinkCombineResultType::FINISHED;
 }
 
 SinkFinalizeType PhysicalDelimJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &client,
-                                             GlobalSinkState &gstate) const {
+                                             OperatorSinkFinalizeInput &input) const {
 	// finalize the distinct HT
 	D_ASSERT(distinct);
-	distinct->Finalize(pipeline, event, client, *distinct->sink_state);
+
+	OperatorSinkFinalizeInput finalize_input {*distinct->sink_state, input.interrupt_state};
+	distinct->Finalize(pipeline, event, client, finalize_input);
 	return SinkFinalizeType::READY;
 }
 

package/src/duckdb/src/execution/operator/join/physical_hash_join.cpp

@@ -210,9 +210,9 @@ SinkResultType PhysicalHashJoin::Sink(ExecutionContext &context, DataChunk &chun
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
-void PhysicalHashJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = gstate_p.Cast<HashJoinGlobalSinkState>();
-	auto &lstate = lstate_p.Cast<HashJoinLocalSinkState>();
+SinkCombineResultType PhysicalHashJoin::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
+	auto &gstate = input.global_state.Cast<HashJoinGlobalSinkState>();
+	auto &lstate = input.local_state.Cast<HashJoinLocalSinkState>();
 	if (lstate.hash_table) {
 		lstate.hash_table->GetSinkCollection().FlushAppendState(lstate.append_state);
 		lock_guard<mutex> local_ht_lock(gstate.lock);
@@ -221,6 +221,8 @@ void PhysicalHashJoin::Combine(ExecutionContext &context, GlobalSinkState &gstat
 	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(*this, lstate.build_executor, "build_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
+
+	return SinkCombineResultType::FINISHED;
 }
 
 //===--------------------------------------------------------------------===//
@@ -362,8 +364,8 @@ public:
 };
 
 SinkFinalizeType PhysicalHashJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                            GlobalSinkState &gstate) const {
-	auto &sink = gstate.Cast<HashJoinGlobalSinkState>();
+                                            OperatorSinkFinalizeInput &input) const {
+	auto &sink = input.global_state.Cast<HashJoinGlobalSinkState>();
 	auto &ht = *sink.hash_table;
 
 	sink.external = ht.RequiresExternalJoin(context.config, sink.local_hash_tables);