duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

package/src/duckdb/src/common/arrow/appender/union_data.cpp

@@ -8,7 +8,7 @@ namespace duckdb {
 // Unions
 //===--------------------------------------------------------------------===//
 void ArrowUnionData::Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
-	result.main_buffer.reserve(capacity * sizeof(int8_t));
+	result.GetMainBuffer().reserve(capacity * sizeof(int8_t));
 
 	for (auto &child : UnionType::CopyMemberTypes(type)) {
 		auto child_buffer = ArrowAppender::InitializeChild(child.second, capacity, result.options);
@@ -22,7 +22,7 @@ void ArrowUnionData::Append(ArrowAppendData &append_data, Vector &input, idx_t f
 	input.ToUnifiedFormat(input_size, format);
 	idx_t size = to - from;
 
-	auto &types_buffer = append_data.main_buffer;
+	auto &types_buffer = append_data.GetMainBuffer();
 
 	duckdb::vector<Vector> child_vectors;
 	for (const auto &child : UnionType::CopyMemberTypes(input.GetType())) {
@@ -43,8 +43,7 @@ void ArrowUnionData::Append(ArrowAppendData &append_data, Vector &input, idx_t f
 		for (idx_t child_idx = 0; child_idx < child_vectors.size(); child_idx++) {
 			child_vectors[child_idx].SetValue(input_idx, child_idx == tag ? resolved_value : Value(nullptr));
 		}
-
-		types_buffer.data()[input_idx] = NumericCast<data_t>(tag);
+		types_buffer.push_back<data_t>(NumericCast<data_t>(tag));
 	}
 
 	for (idx_t child_idx = 0; child_idx < child_vectors.size(); child_idx++) {
@@ -57,7 +56,7 @@ void ArrowUnionData::Append(ArrowAppendData &append_data, Vector &input, idx_t f
 
 void ArrowUnionData::Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
 	result->n_buffers = 1;
-	result->buffers[0] = append_data.main_buffer.data();
+	result->buffers[0] = append_data.GetMainBuffer().data();
 
 	auto &child_types = UnionType::CopyMemberTypes(type);
 	ArrowAppender::AddChildren(append_data, child_types.size());

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

@@ -14,10 +14,10 @@ namespace duckdb {
 // ArrowAppender
 //===--------------------------------------------------------------------===//
 
-ArrowAppender::ArrowAppender(vector<LogicalType> types_p, idx_t initial_capacity, ClientProperties options)
+ArrowAppender::ArrowAppender(vector<LogicalType> types_p, const idx_t initial_capacity, ClientProperties options)
     : types(std::move(types_p)) {
 	for (auto &type : types) {
-		auto entry = ArrowAppender::InitializeChild(type, initial_capacity, options);
+		auto entry = InitializeChild(type, initial_capacity, options);
 		root_data.push_back(std::move(entry));
 	}
 }
@@ -35,6 +35,10 @@ void ArrowAppender::Append(DataChunk &input, idx_t from, idx_t to, idx_t input_s
 	row_count += to - from;
 }
 
+idx_t ArrowAppender::RowCount() const {
+	return row_count;
+}
+
 void ArrowAppender::ReleaseArray(ArrowArray *array) {
 	if (!array || !array->release) {
 		return;
@@ -64,7 +68,7 @@ ArrowArray *ArrowAppender::FinalizeChild(const LogicalType &type, unique_ptr<Arr
 
 	auto &append_data = *append_data_p;
 	result->private_data = append_data_p.release();
-	result->release = ArrowAppender::ReleaseArray;
+	result->release = ReleaseArray;
 	result->n_children = 0;
 	result->null_count = 0;
 	result->offset = 0;
@@ -72,7 +76,7 @@ ArrowArray *ArrowAppender::FinalizeChild(const LogicalType &type, unique_ptr<Arr
 	result->buffers = append_data.buffers.data();
 	result->null_count = NumericCast<int64_t>(append_data.null_count);
 	result->length = NumericCast<int64_t>(append_data.row_count);
-	result->buffers[0] = append_data.validity.data();
+	result->buffers[0] = append_data.GetValidityBuffer().data();
 
 	if (append_data.finalize) {
 		append_data.finalize(append_data, type, result.get());
@@ -138,9 +142,14 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 	case LogicalTypeId::INTEGER:
 		InitializeAppenderForType<ArrowScalarData<int32_t>>(append_data);
 		break;
-	case LogicalTypeId::TIME_TZ:
-		InitializeAppenderForType<ArrowScalarData<int64_t, dtime_tz_t, ArrowTimeTzConverter>>(append_data);
+	case LogicalTypeId::TIME_TZ: {
+		if (append_data.options.arrow_lossless_conversion) {
+			InitializeAppenderForType<ArrowScalarData<int64_t>>(append_data);
+		} else {
+			InitializeAppenderForType<ArrowScalarData<int64_t, dtime_tz_t, ArrowTimeTzConverter>>(append_data);
+		}
 		break;
+	}
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIMESTAMP_SEC:
 	case LogicalTypeId::TIMESTAMP_MS:
@@ -150,9 +159,23 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 	case LogicalTypeId::BIGINT:
 		InitializeAppenderForType<ArrowScalarData<int64_t>>(append_data);
 		break;
+	case LogicalTypeId::UUID:
+		if (append_data.options.arrow_lossless_conversion) {
+			InitializeAppenderForType<ArrowScalarData<hugeint_t, hugeint_t, ArrowUUIDBlobConverter>>(append_data);
+		} else {
+			if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
+				InitializeAppenderForType<ArrowVarcharData<hugeint_t, ArrowUUIDConverter>>(append_data);
+			} else {
+				InitializeAppenderForType<ArrowVarcharData<hugeint_t, ArrowUUIDConverter, int32_t>>(append_data);
+			}
+		}
+		break;
 	case LogicalTypeId::HUGEINT:
 		InitializeAppenderForType<ArrowScalarData<hugeint_t>>(append_data);
 		break;
+	case LogicalTypeId::UHUGEINT:
+		InitializeAppenderForType<ArrowScalarData<uhugeint_t>>(append_data);
+		break;
 	case LogicalTypeId::UTINYINT:
 		InitializeAppenderForType<ArrowScalarData<uint8_t>>(append_data);
 		break;
@@ -190,19 +213,22 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 		}
 		break;
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::BIT:
-		if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-			InitializeAppenderForType<ArrowVarcharData<string_t>>(append_data);
+		if (append_data.options.produce_arrow_string_view) {
+			InitializeAppenderForType<ArrowVarcharToStringViewData>(append_data);
 		} else {
-			InitializeAppenderForType<ArrowVarcharData<string_t, ArrowVarcharConverter, int32_t>>(append_data);
+			if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
+				InitializeAppenderForType<ArrowVarcharData<>>(append_data);
+			} else {
+				InitializeAppenderForType<ArrowVarcharData<string_t, ArrowVarcharConverter, int32_t>>(append_data);
+			}
 		}
 		break;
-	case LogicalTypeId::UUID:
+	case LogicalTypeId::BLOB:
+	case LogicalTypeId::BIT:
 		if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-			InitializeAppenderForType<ArrowVarcharData<hugeint_t, ArrowUUIDConverter>>(append_data);
+			InitializeAppenderForType<ArrowVarcharData<>>(append_data);
 		} else {
-			InitializeAppenderForType<ArrowVarcharData<hugeint_t, ArrowUUIDConverter, int32_t>>(append_data);
+			InitializeAppenderForType<ArrowVarcharData<string_t, ArrowVarcharConverter, int32_t>>(append_data);
 		}
 		break;
 	case LogicalTypeId::ENUM:
@@ -233,10 +259,18 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 		InitializeAppenderForType<ArrowFixedSizeListData>(append_data);
 		break;
 	case LogicalTypeId::LIST: {
-		if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-			InitializeAppenderForType<ArrowListData<int64_t>>(append_data);
+		if (append_data.options.arrow_use_list_view) {
+			if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
+				InitializeAppenderForType<ArrowListViewData<>>(append_data);
+			} else {
+				InitializeAppenderForType<ArrowListViewData<int32_t>>(append_data);
+			}
 		} else {
-			InitializeAppenderForType<ArrowListData<int32_t>>(append_data);
+			if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
+				InitializeAppenderForType<ArrowListData<>>(append_data);
+			} else {
+				InitializeAppenderForType<ArrowListData<int32_t>>(append_data);
+			}
 		}
 		break;
 	}
@@ -249,18 +283,18 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 	}
 }
 
-unique_ptr<ArrowAppendData> ArrowAppender::InitializeChild(const LogicalType &type, idx_t capacity,
+unique_ptr<ArrowAppendData> ArrowAppender::InitializeChild(const LogicalType &type, const idx_t capacity,
                                                            ClientProperties &options) {
 	auto result = make_uniq<ArrowAppendData>(options);
 	InitializeFunctionPointers(*result, type);
 
-	auto byte_count = (capacity + 7) / 8;
-	result->validity.reserve(byte_count);
+	const auto byte_count = (capacity + 7) / 8;
+	result->GetValidityBuffer().reserve(byte_count);
 	result->initialize(*result, type, capacity);
 	return result;
 }
 
-void ArrowAppender::AddChildren(ArrowAppendData &data, idx_t count) {
+void ArrowAppender::AddChildren(ArrowAppendData &data, const idx_t count) {
 	data.child_pointers.resize(count);
 	data.child_arrays.resize(count);
 	for (idx_t i = 0; i < count; i++) {

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

@@ -11,6 +11,7 @@
 #include "duckdb/common/vector.hpp"
 #include <list>
 #include "duckdb/common/arrow/arrow_appender.hpp"
+#include "duckdb/common/arrow/schema_metadata.hpp"
 
 namespace duckdb {
 
@@ -43,6 +44,8 @@ struct DuckDBArrowSchemaHolder {
 	//! This holds strings created to represent decimal types
 	vector<unsafe_unique_array<char>> owned_type_names;
 	vector<unsafe_unique_array<char>> owned_column_names;
+	//! This holds any values created for metadata info
+	vector<unsafe_unique_array<char>> metadata_info;
 };
 
 static void ReleaseDuckDBArrowSchema(ArrowSchema *schema) {
@@ -121,24 +124,77 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 	case LogicalTypeId::FLOAT:
 		child.format = "f";
 		break;
-	case LogicalTypeId::HUGEINT:
-		child.format = "d:38,0";
+	case LogicalTypeId::HUGEINT: {
+		if (options.arrow_lossless_conversion) {
+			child.format = "w:16";
+			auto schema_metadata = ArrowSchemaMetadata::MetadataFromName("duckdb.hugeint");
+			root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
+			child.metadata = root_holder.metadata_info.back().get();
+		} else {
+			child.format = "d:38,0";
+		}
+		break;
+	}
+	case LogicalTypeId::UHUGEINT: {
+		child.format = "w:16";
+		auto schema_metadata = ArrowSchemaMetadata::MetadataFromName("duckdb.uhugeint");
+		root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
+		child.metadata = root_holder.metadata_info.back().get();
 		break;
+	}
 	case LogicalTypeId::DOUBLE:
 		child.format = "g";
 		break;
-	case LogicalTypeId::UUID:
+	case LogicalTypeId::UUID: {
+		if (options.arrow_lossless_conversion) {
+			// This is a canonical extension, hence needs the "arrow." prefix
+			child.format = "w:16";
+			auto schema_metadata = ArrowSchemaMetadata::MetadataFromName("arrow.uuid");
+			root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
+			child.metadata = root_holder.metadata_info.back().get();
+		} else {
+			if (options.produce_arrow_string_view) {
+				child.format = "vu";
+			} else {
+				if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
+					child.format = "U";
+				} else {
+					child.format = "u";
+				}
+			}
+		}
+		break;
+	}
 	case LogicalTypeId::VARCHAR:
-		if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-			child.format = "U";
+		if (type.IsJSONType()) {
+			auto schema_metadata = ArrowSchemaMetadata::MetadataFromName("arrow.json");
+			root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
+			child.metadata = root_holder.metadata_info.back().get();
+		}
+		if (options.produce_arrow_string_view) {
+			child.format = "vu";
 		} else {
-			child.format = "u";
+			if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
+				child.format = "U";
+			} else {
+				child.format = "u";
+			}
 		}
 		break;
 	case LogicalTypeId::DATE:
 		child.format = "tdD";
 		break;
-	case LogicalTypeId::TIME_TZ:
+	case LogicalTypeId::TIME_TZ: {
+		if (options.arrow_lossless_conversion) {
+			child.format = "w:8";
+			auto schema_metadata = ArrowSchemaMetadata::MetadataFromName("duckdb.time_tz");
+			root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
+			child.metadata = root_holder.metadata_info.back().get();
+		} else {
+			child.format = "ttu";
+		}
+		break;
+	}
 	case LogicalTypeId::TIME:
 		child.format = "ttu";
 		break;
@@ -176,19 +232,38 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		break;
 	}
 	case LogicalTypeId::BLOB:
+		if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
+			child.format = "Z";
+		} else {
+			child.format = "z";
+		}
+		break;
 	case LogicalTypeId::BIT: {
 		if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
 			child.format = "Z";
 		} else {
 			child.format = "z";
 		}
+		if (options.arrow_lossless_conversion) {
+			auto schema_metadata = ArrowSchemaMetadata::MetadataFromName("duckdb.bit");
+			root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
+			child.metadata = root_holder.metadata_info.back().get();
+		}
 		break;
 	}
 	case LogicalTypeId::LIST: {
-		if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-			child.format = "+L";
+		if (options.arrow_use_list_view) {
+			if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
+				child.format = "+vL";
+			} else {
+				child.format = "+vl";
+			}
 		} else {
-			child.format = "+l";
+			if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
+				child.format = "+L";
+			} else {
+				child.format = "+l";
+			}
 		}
 		child.n_children = 1;
 		root_holder.nested_children.emplace_back();

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

@@ -0,0 +1,142 @@
+#include "duckdb/common/arrow/arrow_merge_event.hpp"
+#include "duckdb/storage/storage_info.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Arrow Batch Task
+//===--------------------------------------------------------------------===//
+
+ArrowBatchTask::ArrowBatchTask(ArrowQueryResult &result, vector<idx_t> record_batch_indices, Executor &executor,
+                               shared_ptr<Event> event_p, BatchCollectionChunkScanState scan_state,
+                               vector<string> names, idx_t batch_size)
+    : ExecutorTask(executor, event_p), result(result), record_batch_indices(std::move(record_batch_indices)),
+      event(std::move(event_p)), batch_size(batch_size), names(std::move(names)), scan_state(std::move(scan_state)) {
+}
+
+void ArrowBatchTask::ProduceRecordBatches() {
+	auto &arrays = result.Arrays();
+	auto arrow_options = executor.context.GetClientProperties();
+	for (auto &index : record_batch_indices) {
+		auto &array = arrays[index];
+		D_ASSERT(array);
+		idx_t count;
+		count = ArrowUtil::FetchChunk(scan_state, arrow_options, batch_size, &array->arrow_array);
+		(void)count;
+		D_ASSERT(count != 0);
+	}
+}
+
+TaskExecutionResult ArrowBatchTask::ExecuteTask(TaskExecutionMode mode) {
+	ProduceRecordBatches();
+	event->FinishTask();
+	return TaskExecutionResult::TASK_FINISHED;
+}
+
+//===--------------------------------------------------------------------===//
+// Arrow Merge Event
+//===--------------------------------------------------------------------===//
+
+ArrowMergeEvent::ArrowMergeEvent(ArrowQueryResult &result, BatchedDataCollection &batches, Pipeline &pipeline_p)
+    : BasePipelineEvent(pipeline_p), result(result), batches(batches) {
+	record_batch_size = result.BatchSize();
+}
+
+namespace {
+
+struct BatchesForTask {
+	idx_t tuple_count;
+	BatchedChunkIteratorRange batches;
+};
+
+struct BatchesToTaskTransformer {
+public:
+	explicit BatchesToTaskTransformer(BatchedDataCollection &batches) : batches(batches), batch_index(0) {
+		batch_count = batches.BatchCount();
+	}
+	idx_t GetIndex() const {
+		return batch_index;
+	}
+	bool TryGetNextBatchSize(idx_t &tuple_count) {
+		if (batch_index >= batch_count) {
+			return false;
+		}
+		auto internal_index = batches.IndexToBatchIndex(batch_index++);
+		auto tuples_in_batch = batches.BatchSize(internal_index);
+		tuple_count = tuples_in_batch;
+		return true;
+	}
+
+public:
+	BatchedDataCollection &batches;
+	idx_t batch_index;
+	idx_t batch_count;
+};
+
+} // namespace
+
+void ArrowMergeEvent::Schedule() {
+	vector<shared_ptr<Task>> tasks;
+
+	BatchesToTaskTransformer transformer(batches);
+	vector<BatchesForTask> task_data;
+	bool finished = false;
+	// First we convert our list of batches into units of Storage::ROW_GROUP_SIZE tuples each
+	while (!finished) {
+		idx_t tuples_for_task = 0;
+		idx_t start_index = transformer.GetIndex();
+		idx_t end_index = start_index;
+		while (tuples_for_task < Storage::ROW_GROUP_SIZE) {
+			idx_t batch_size;
+			if (!transformer.TryGetNextBatchSize(batch_size)) {
+				finished = true;
+				break;
+			}
+			end_index++;
+			tuples_for_task += batch_size;
+		}
+		if (start_index == end_index) {
+			break;
+		}
+		BatchesForTask batches_for_task;
+		batches_for_task.tuple_count = tuples_for_task;
+		batches_for_task.batches = batches.BatchRange(start_index, end_index);
+		task_data.push_back(batches_for_task);
+	}
+
+	// Now we produce tasks from these units
+	// Every task is given a scan_state created from the range of batches
+	// and a vector of indices indicating the arrays (record batches) they should populate
+	idx_t record_batch_index = 0;
+	for (auto &data : task_data) {
+		const auto tuples = data.tuple_count;
+
+		auto full_batches = tuples / record_batch_size;
+		auto remainder = tuples % record_batch_size;
+		auto total_batches = full_batches + !!remainder;
+
+		vector<idx_t> record_batch_indices(total_batches);
+		for (idx_t i = 0; i < total_batches; i++) {
+			record_batch_indices[i] = record_batch_index++;
+		}
+
+		BatchCollectionChunkScanState scan_state(batches, data.batches, pipeline->executor.context);
+		tasks.push_back(make_uniq<ArrowBatchTask>(result, std::move(record_batch_indices), pipeline->executor,
+		                                          shared_from_this(), std::move(scan_state), result.names,
+		                                          record_batch_size));
+	}
+
+	// Allocate the list of record batches inside the query result
+	{
+		vector<unique_ptr<ArrowArrayWrapper>> arrays;
+		arrays.resize(record_batch_index);
+		for (idx_t i = 0; i < record_batch_index; i++) {
+			arrays[i] = make_uniq<ArrowArrayWrapper>();
+		}
+		result.SetArrowData(std::move(arrays));
+	}
+	D_ASSERT(!tasks.empty());
+	SetTasks(std::move(tasks));
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,56 @@
+#include "duckdb/common/arrow/arrow_query_result.hpp"
+#include "duckdb/common/to_string.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/common/box_renderer.hpp"
+#include "duckdb/common/arrow/arrow_converter.hpp"
+
+namespace duckdb {
+
+ArrowQueryResult::ArrowQueryResult(StatementType statement_type, StatementProperties properties, vector<string> names_p,
+                                   vector<LogicalType> types_p, ClientProperties client_properties, idx_t batch_size)
+    : QueryResult(QueryResultType::ARROW_RESULT, statement_type, std::move(properties), std::move(types_p),
+                  std::move(names_p), std::move(client_properties)),
+      batch_size(batch_size) {
+}
+
+ArrowQueryResult::ArrowQueryResult(ErrorData error) : QueryResult(QueryResultType::ARROW_RESULT, std::move(error)) {
+}
+
+unique_ptr<DataChunk> ArrowQueryResult::Fetch() {
+	throw NotImplementedException("Can't 'Fetch' from ArrowQueryResult");
+}
+unique_ptr<DataChunk> ArrowQueryResult::FetchRaw() {
+	throw NotImplementedException("Can't 'FetchRaw' from ArrowQueryResult");
+}
+
+string ArrowQueryResult::ToString() {
+	// FIXME: can't throw an exception here as it's used for verification
+	return "";
+}
+
+vector<unique_ptr<ArrowArrayWrapper>> ArrowQueryResult::ConsumeArrays() {
+	if (HasError()) {
+		throw InvalidInputException("Attempting to fetch ArrowArrays from an unsuccessful query result\n: Error %s",
+		                            GetError());
+	}
+	return std::move(arrays);
+}
+
+vector<unique_ptr<ArrowArrayWrapper>> &ArrowQueryResult::Arrays() {
+	if (HasError()) {
+		throw InvalidInputException("Attempting to fetch ArrowArrays from an unsuccessful query result\n: Error %s",
+		                            GetError());
+	}
+	return arrays;
+}
+
+void ArrowQueryResult::SetArrowData(vector<unique_ptr<ArrowArrayWrapper>> arrays) {
+	D_ASSERT(this->arrays.empty());
+	this->arrays = std::move(arrays);
+}
+
+idx_t ArrowQueryResult::BatchSize() const {
+	return batch_size;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,37 @@
+#include "duckdb/common/arrow/physical_arrow_batch_collector.hpp"
+#include "duckdb/common/types/batched_data_collection.hpp"
+#include "duckdb/common/arrow/arrow_query_result.hpp"
+#include "duckdb/common/arrow/arrow_merge_event.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/common/arrow/physical_arrow_collector.hpp"
+
+namespace duckdb {
+
+unique_ptr<GlobalSinkState> PhysicalArrowBatchCollector::GetGlobalSinkState(ClientContext &context) const {
+	return make_uniq<ArrowBatchGlobalState>(context, *this);
+}
+
+SinkFinalizeType PhysicalArrowBatchCollector::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
+                                                       OperatorSinkFinalizeInput &input) const {
+	auto &gstate = input.global_state.Cast<ArrowBatchGlobalState>();
+
+	auto total_tuple_count = gstate.data.Count();
+	if (total_tuple_count == 0) {
+		// Create the result containing a single empty result conversion
+		gstate.result = make_uniq<ArrowQueryResult>(statement_type, properties, names, types,
+		                                            context.GetClientProperties(), record_batch_size);
+		return SinkFinalizeType::READY;
+	}
+
+	// Already create the final query result
+	gstate.result = make_uniq<ArrowQueryResult>(statement_type, properties, names, types, context.GetClientProperties(),
+	                                            record_batch_size);
+	// Spawn an event that will populate the conversion result
+	auto &arrow_result = gstate.result->Cast<ArrowQueryResult>();
+	auto new_event = make_shared_ptr<ArrowMergeEvent>(arrow_result, gstate.data, pipeline);
+	event.InsertEvent(std::move(new_event));
+
+	return SinkFinalizeType::READY;
+}
+
+} // namespace duckdb