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

package/src/duckdb/src/include/duckdb/planner/operator/logical_delete.hpp

@@ -27,6 +27,10 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
@@ -34,5 +38,8 @@ public:
 protected:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void ResolveTypes() override;
+
+private:
+	LogicalDelete(ClientContext &context, const string &catalog, const string &schema, const string &table);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_delim_get.hpp

@@ -35,6 +35,9 @@ public:
 	}
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_distinct.hpp

@@ -19,13 +19,8 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DISTINCT;
 
 public:
-	explicit LogicalDistinct(DistinctType distinct_type)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type) {
-	}
-	explicit LogicalDistinct(vector<unique_ptr<Expression>> targets, DistinctType distinct_type)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type),
-	      distinct_targets(std::move(targets)) {
-	}
+	explicit LogicalDistinct(DistinctType distinct_type);
+	explicit LogicalDistinct(vector<unique_ptr<Expression>> targets, DistinctType distinct_type);
 
 	//! Whether or not this is a DISTINCT or DISTINCT ON
 	DistinctType distinct_type;
@@ -43,9 +38,10 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
+	void ResolveTypes() override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_dummy_scan.hpp

@@ -34,6 +34,8 @@ public:
 	}
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_empty_result.hpp

@@ -34,6 +34,8 @@ public:
 	}
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	idx_t EstimateCardinality(ClientContext &context) override {
 		return 0;
 	}

package/src/duckdb/src/include/duckdb/planner/operator/logical_explain.hpp

@@ -34,6 +34,10 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override {
 		return 3;
 	}

package/src/duckdb/src/include/duckdb/planner/operator/logical_expression_get.hpp

@@ -37,6 +37,9 @@ public:
 	}
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	idx_t EstimateCardinality(ClientContext &context) override {
 		return expressions.size();
 	}

package/src/duckdb/src/include/duckdb/planner/operator/logical_filter.hpp

@@ -28,6 +28,9 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	bool SplitPredicates() {
 		return SplitPredicates(expressions);
 	}

package/src/duckdb/src/include/duckdb/planner/operator/logical_insert.hpp

@@ -63,6 +63,9 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void ResolveTypes() override;
@@ -70,5 +73,8 @@ protected:
 	idx_t EstimateCardinality(ClientContext &context) override;
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
+
+private:
+	LogicalInsert(ClientContext &context, const string &catalog, const string &schema, const string &table);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_limit.hpp

@@ -35,6 +35,9 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void ResolveTypes() override;
 };

package/src/duckdb/src/include/duckdb/planner/operator/logical_limit_percent.hpp

@@ -39,6 +39,9 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_materialized_cte.hpp

@@ -13,8 +13,7 @@
 namespace duckdb {
 
 class LogicalMaterializedCTE : public LogicalOperator {
-	LogicalMaterializedCTE(idx_t table_index)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_MATERIALIZED_CTE), table_index(table_index) {
+	explicit LogicalMaterializedCTE() : LogicalOperator(LogicalOperatorType::LOGICAL_MATERIALIZED_CTE) {
 	}
 
 public:
@@ -39,6 +38,10 @@ public:
 	}
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	vector<idx_t> GetTableIndex() const override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_order.hpp

@@ -21,51 +21,23 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_ORDER_BY;
 
 public:
-	explicit LogicalOrder(vector<BoundOrderByNode> orders)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_ORDER_BY), orders(std::move(orders)) {
-	}
+	explicit LogicalOrder(vector<BoundOrderByNode> orders);
 
 	vector<BoundOrderByNode> orders;
 	vector<idx_t> projections;
 
 public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		auto child_bindings = children[0]->GetColumnBindings();
-		if (projections.empty()) {
-			return child_bindings;
-		}
-
-		vector<ColumnBinding> result;
-		for (auto &col_idx : projections) {
-			result.push_back(child_bindings[col_idx]);
-		}
-		return result;
-	}
+	vector<ColumnBinding> GetColumnBindings() override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
-	string ParamsToString() const override {
-		string result = "ORDERS:\n";
-		for (idx_t i = 0; i < orders.size(); i++) {
-			if (i > 0) {
-				result += "\n";
-			}
-			result += orders[i].expression->GetName();
-		}
-		return result;
-	}
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
+	string ParamsToString() const override;
 
 protected:
-	void ResolveTypes() override {
-		const auto child_types = children[0]->types;
-		if (projections.empty()) {
-			types = child_types;
-		} else {
-			for (auto &col_idx : projections) {
-				types.push_back(child_types[col_idx]);
-			}
-		}
-	}
+	void ResolveTypes() override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_pivot.hpp

@@ -31,10 +31,16 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 
 protected:
 	void ResolveTypes() override;
+
+private:
+	LogicalPivot();
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_positional_join.hpp

@@ -27,5 +27,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_projection.hpp

@@ -26,6 +26,9 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_recursive_cte.hpp

@@ -13,9 +13,7 @@
 namespace duckdb {
 
 class LogicalRecursiveCTE : public LogicalOperator {
-	LogicalRecursiveCTE(idx_t table_index, idx_t column_count, bool union_all)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE), union_all(union_all), table_index(table_index),
-	      column_count(column_count) {
+	LogicalRecursiveCTE() : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE) {
 	}
 
 public:
@@ -41,6 +39,10 @@ public:
 	}
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_reset.hpp

@@ -30,6 +30,10 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_sample.hpp

@@ -31,8 +31,14 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void ResolveTypes() override;
+
+private:
+	LogicalSample();
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_set.hpp

@@ -31,6 +31,10 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_set_operation.hpp

@@ -40,6 +40,10 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_show.hpp

@@ -30,6 +30,9 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void ResolveTypes() override {
 		types = {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR,

package/src/duckdb/src/include/duckdb/planner/operator/logical_simple.hpp

@@ -28,6 +28,9 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_top_n.hpp

@@ -35,6 +35,10 @@ public:
 	}
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_unnest.hpp

@@ -28,6 +28,8 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_update.hpp

@@ -33,11 +33,17 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 	string GetName() const override;
 
 protected:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void ResolveTypes() override;
+
+private:
+	LogicalUpdate(ClientContext &context, const string &catalog, const string &schema, const string &table);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_window.hpp

@@ -29,6 +29,9 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/tableref/bound_pivotref.hpp

@@ -25,6 +25,9 @@ struct BoundPivotInfo {
 	vector<string> pivot_values;
 	//! The set of aggregate functions that is being executed
 	vector<unique_ptr<Expression>> aggregates;
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static BoundPivotInfo FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class BoundPivotRef : public BoundTableRef {

package/src/duckdb/src/main/relation/join_relation.cpp

@@ -52,7 +52,7 @@ const vector<ColumnDefinition> &JoinRelation::Columns() {
 
 string JoinRelation::ToString(idx_t depth) {
 	string str = RenderWhitespace(depth);
-	str += "Join " + EnumUtil::ToString(join_type);
+	str += "Join " + EnumUtil::ToString(join_ref_type) + " " + EnumUtil::ToString(join_type);
 	if (condition) {
 		str += " " + condition->GetName();
 	}

package/src/duckdb/src/optimizer/deliminator.cpp

@@ -15,10 +15,12 @@ namespace duckdb {
 
 struct DelimCandidate {
 public:
-	explicit DelimCandidate(LogicalDelimJoin &delim_join) : delim_join(delim_join), delim_get_count(0) {
+	explicit DelimCandidate(unique_ptr<LogicalOperator> &op, LogicalDelimJoin &delim_join)
+	    : op(op), delim_join(delim_join), delim_get_count(0) {
 	}
 
 public:
+	unique_ptr<LogicalOperator> &op;
 	LogicalDelimJoin &delim_join;
 	vector<reference<unique_ptr<LogicalOperator>>> joins;
 	idx_t delim_get_count;
@@ -61,7 +63,7 @@ unique_ptr<LogicalOperator> Deliminator::Optimize(unique_ptr<LogicalOperator> op
 					}
 				}
 			}
-			delim_join.type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
+			candidate.op = LogicalComparisonJoin::FromDelimJoin(delim_join);
 		}
 	}
 
@@ -78,7 +80,7 @@ void Deliminator::FindCandidates(unique_ptr<LogicalOperator> &op, vector<DelimCa
 		return;
 	}
 
-	candidates.emplace_back(op->Cast<LogicalDelimJoin>());
+	candidates.emplace_back(op, op->Cast<LogicalDelimJoin>());
 	auto &candidate = candidates.back();
 
 	// DelimGets are in the RHS

package/src/duckdb/src/parallel/pipeline.cpp

@@ -218,23 +218,6 @@ void Pipeline::Ready() {
 	std::reverse(operators.begin(), operators.end());
 }
 
-void Pipeline::Finalize(Event &event) {
-	if (executor.HasError()) {
-		return;
-	}
-	D_ASSERT(ready);
-	try {
-		auto sink_state = sink->Finalize(*this, event, executor.context, *sink->sink_state);
-		sink->sink_state->state = sink_state;
-	} catch (Exception &ex) { // LCOV_EXCL_START
-		executor.PushError(PreservedError(ex));
-	} catch (std::exception &ex) {
-		executor.PushError(PreservedError(ex));
-	} catch (...) {
-		executor.PushError(PreservedError("Unknown exception in Finalize!"));
-	} // LCOV_EXCL_STOP
-}
-
 void Pipeline::AddDependency(shared_ptr<Pipeline> &pipeline) {
 	D_ASSERT(pipeline);
 	dependencies.push_back(weak_ptr<Pipeline>(pipeline));

package/src/duckdb/src/parallel/pipeline_executor.cpp

@@ -171,9 +171,7 @@ PipelineExecuteResult PipelineExecutor::Execute(idx_t max_chunks) {
 		return PipelineExecuteResult::NOT_FINISHED;
 	}
 
-	PushFinalize();
-
-	return PipelineExecuteResult::FINISHED;
+	return PushFinalize();
 }
 
 PipelineExecuteResult PipelineExecutor::Execute() {
@@ -238,24 +236,45 @@ OperatorResultType PipelineExecutor::ExecutePushInternal(DataChunk &input, idx_t
 	}
 }
 
-void PipelineExecutor::PushFinalize() {
+PipelineExecuteResult PipelineExecutor::PushFinalize() {
 	if (finalized) {
 		throw InternalException("Calling PushFinalize on a pipeline that has been finalized already");
 	}
 
 	D_ASSERT(local_sink_state);
 
-	finalized = true;
+	// Run the combine for the sink
+	OperatorSinkCombineInput combine_input {*pipeline.sink->sink_state, *local_sink_state, interrupt_state};
+
+#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
+	if (debug_blocked_combine_count < debug_blocked_target_count) {
+		debug_blocked_combine_count++;
+
+		auto &callback_state = combine_input.interrupt_state;
+		std::thread rewake_thread([callback_state] {
+			std::this_thread::sleep_for(std::chrono::milliseconds(1));
+			callback_state.Callback();
+		});
+		rewake_thread.detach();
 
-	// run the combine for the sink
-	pipeline.sink->Combine(context, *pipeline.sink->sink_state, *local_sink_state);
+		return PipelineExecuteResult::INTERRUPTED;
+	}
+#endif
+	auto result = pipeline.sink->Combine(context, combine_input);
 
+	if (result == SinkCombineResultType::BLOCKED) {
+		return PipelineExecuteResult::INTERRUPTED;
+	}
+
+	finalized = true;
 	// flush all query profiler info
 	for (idx_t i = 0; i < intermediate_states.size(); i++) {
 		intermediate_states[i]->Finalize(pipeline.operators[i].get(), context);
 	}
 	pipeline.executor.Flush(thread);
 	local_sink_state.reset();
+
+	return PipelineExecuteResult::FINISHED;
 }
 
 // TODO: Refactoring the StreamingQueryResult to use Push-based execution should eliminate the need for this code

package/src/duckdb/src/parallel/pipeline_finish_event.cpp

@@ -1,16 +1,70 @@
 #include "duckdb/parallel/pipeline_finish_event.hpp"
 #include "duckdb/execution/executor.hpp"
+#include "duckdb/parallel/interrupt.hpp"
 
 namespace duckdb {
 
+//! The PipelineFinishTask calls Finalize on the sink. Note that this is a single-threaded operation, but is executed
+//! in a task to allow the Finalize call to block (e.g. for async I/O)
+class PipelineFinishTask : public ExecutorTask {
+public:
+	explicit PipelineFinishTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
+	    : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(std::move(event_p)) {
+	}
+
+	Pipeline &pipeline;
+	shared_ptr<Event> event;
+
+public:
+	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
+		auto sink = pipeline.GetSink();
+		InterruptState interrupt_state(shared_from_this());
+		OperatorSinkFinalizeInput finalize_input {*sink->sink_state, interrupt_state};
+
+#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
+		if (debug_blocked_count < debug_blocked_target_count) {
+			debug_blocked_count++;
+
+			auto &callback_state = interrupt_state;
+			std::thread rewake_thread([callback_state] {
+				std::this_thread::sleep_for(std::chrono::milliseconds(1));
+				callback_state.Callback();
+			});
+			rewake_thread.detach();
+
+			return TaskExecutionResult::TASK_BLOCKED;
+		}
+#endif
+		auto sink_state = sink->Finalize(pipeline, *event, executor.context, finalize_input);
+
+		if (sink_state == SinkFinalizeType::BLOCKED) {
+			return TaskExecutionResult::TASK_BLOCKED;
+		}
+
+		sink->sink_state->state = sink_state;
+		event->FinishTask();
+		return TaskExecutionResult::TASK_FINISHED;
+	}
+
+private:
+#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
+	//! Debugging state: number of times blocked
+	int debug_blocked_count = 0;
+	//! Number of times the Finalize will block before actually returning data
+	int debug_blocked_target_count = 1;
+#endif
+};
+
 PipelineFinishEvent::PipelineFinishEvent(shared_ptr<Pipeline> pipeline_p) : BasePipelineEvent(std::move(pipeline_p)) {
 }
 
 void PipelineFinishEvent::Schedule() {
+	vector<shared_ptr<Task>> tasks;
+	tasks.push_back(make_uniq<PipelineFinishTask>(*pipeline, shared_from_this()));
+	SetTasks(std::move(tasks));
 }
 
 void PipelineFinishEvent::FinishEvent() {
-	pipeline->Finalize(*this);
 }
 
 } // namespace duckdb