duckdb 0.7.2-dev2995.0 → 0.7.2-dev3117.0

package/src/duckdb/src/include/duckdb/common/enums/join_type.hpp

@@ -29,13 +29,13 @@ enum class JoinType : uint8_t {
 	             // (and NULL if no partner is found)
 };
 
-//! Convert join type to string
-DUCKDB_API string JoinTypeToString(JoinType type);
-
 //! True if join is left or full outer join
 bool IsLeftOuterJoin(JoinType type);
 
 //! True if join is rght or full outer join
 bool IsRightOuterJoin(JoinType type);
 
+// **DEPRECATED**: Use EnumUtil directly instead.
+string JoinTypeToString(JoinType type);
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/physical_operator_type.hpp

@@ -30,6 +30,7 @@ enum class PhysicalOperatorType : uint8_t {
 	FILTER,
 	PROJECTION,
 	COPY_TO_FILE,
+	BATCH_COPY_TO_FILE,
 	RESERVOIR_SAMPLE,
 	STREAMING_SAMPLE,
 	STREAMING_WINDOW,

package/src/duckdb/src/include/duckdb/common/exception.hpp

@@ -10,11 +10,11 @@
 
 #include "duckdb/common/assert.hpp"
 #include "duckdb/common/exception_format_value.hpp"
-#include "duckdb/common/vector.hpp"
 #include "duckdb/common/shared_ptr.hpp"
 #include "duckdb/common/map.hpp"
 #include "duckdb/common/typedefs.hpp"
 
+#include <vector>
 #include <stdexcept>
 
 namespace duckdb {
@@ -105,14 +105,14 @@ public:
 
 	template <typename... Args>
 	static string ConstructMessage(const string &msg, Args... params) {
-		vector<ExceptionFormatValue> values;
+		std::vector<ExceptionFormatValue> values;
 		return ConstructMessageRecursive(msg, values, params...);
 	}
 
-	DUCKDB_API static string ConstructMessageRecursive(const string &msg, vector<ExceptionFormatValue> &values);
+	DUCKDB_API static string ConstructMessageRecursive(const string &msg, std::vector<ExceptionFormatValue> &values);
 
 	template <class T, typename... Args>
-	static string ConstructMessageRecursive(const string &msg, vector<ExceptionFormatValue> &values, T param,
+	static string ConstructMessageRecursive(const string &msg, std::vector<ExceptionFormatValue> &values, T param,
 	                                        Args... params) {
 		values.push_back(ExceptionFormatValue::CreateFormatValue<T>(param));
 		return ConstructMessageRecursive(msg, values, params...);

package/src/duckdb/src/include/duckdb/common/exception_format_value.hpp

@@ -10,7 +10,8 @@
 
 #include "duckdb/common/string.hpp"
 #include "duckdb/common/hugeint.hpp"
-#include "duckdb/common/vector.hpp"
+
+#include <vector>
 
 namespace duckdb {
 
@@ -40,7 +41,7 @@ public:
 	static ExceptionFormatValue CreateFormatValue(T value) {
 		return int64_t(value);
 	}
-	static string Format(const string &msg, vector<ExceptionFormatValue> &values);
+	static string Format(const string &msg, std::vector<ExceptionFormatValue> &values);
 };
 
 template <>

package/src/duckdb/src/include/duckdb/common/multi_file_reader_options.hpp

@@ -9,6 +9,8 @@
 #pragma once
 
 #include "duckdb/common/types.hpp"
+#include "duckdb/common/hive_partitioning.hpp"
+#include "re2/re2.h"
 
 namespace duckdb {
 class Serializer;
@@ -18,11 +20,53 @@ struct BindInfo;
 struct MultiFileReaderOptions {
 	bool filename = false;
 	bool hive_partitioning = false;
+	bool auto_detect_hive_partitioning = true;
 	bool union_by_name = false;
 
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 	DUCKDB_API static MultiFileReaderOptions Deserialize(Deserializer &source);
 	DUCKDB_API void AddBatchInfo(BindInfo &bind_info) const;
+
+	static bool AutoDetectHivePartitioning(const vector<string> &files) {
+		if (files.empty()) {
+			return false;
+		}
+
+		std::unordered_set<string> uset;
+		idx_t splits_size;
+		{
+			//	front file
+			auto splits = StringUtil::Split(files.front(), FileSystem::PathSeparator());
+			splits_size = splits.size();
+			if (splits.size() < 2) {
+				return false;
+			}
+			for (auto it = splits.begin(); it != std::prev(splits.end()); it++) {
+				auto part = StringUtil::Split(*it, "=");
+				if (part.size() == 2) {
+					uset.insert(part.front());
+				}
+			}
+		}
+		if (uset.empty()) {
+			return false;
+		}
+		for (auto &file : files) {
+			auto splits = StringUtil::Split(file, FileSystem::PathSeparator());
+			if (splits.size() != splits_size) {
+				return false;
+			}
+			for (auto it = splits.begin(); it != std::prev(splits.end()); it++) {
+				auto part = StringUtil::Split(*it, "=");
+				if (part.size() == 2) {
+					if (uset.find(part.front()) == uset.end()) {
+						return false;
+					}
+				}
+			}
+		}
+		return true;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp

@@ -0,0 +1,93 @@
+#pragma once
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
+namespace duckdb {
+
+class BinaryDeserializer : public FormatDeserializer {
+public:
+	template <class T>
+	static unique_ptr<T> Deserialize(data_ptr_t ptr, idx_t length) {
+		BinaryDeserializer deserializer(ptr, length);
+		deserializer.OnObjectBegin();
+		auto result = T::FormatDeserialize(deserializer);
+		deserializer.OnObjectEnd();
+		return result;
+	}
+
+private:
+	explicit BinaryDeserializer(data_ptr_t ptr, idx_t length) : ptr(ptr), end_ptr(ptr + length) {
+		deserialize_enum_from_string = false;
+	}
+	struct State {
+		uint32_t expected_field_count;
+		idx_t expected_size;
+		uint32_t read_field_count;
+		State(uint32_t expected_field_count, idx_t expected_size)
+		    : expected_field_count(expected_field_count), expected_size(expected_size), read_field_count(0) {
+		}
+	};
+
+	const char *current_tag = nullptr;
+	data_ptr_t ptr;
+	data_ptr_t end_ptr;
+	vector<State> stack;
+
+	template <class T>
+	T ReadPrimitive() {
+		T value;
+		ReadData((data_ptr_t)&value, sizeof(T));
+		return value;
+	}
+
+	void ReadData(data_ptr_t buffer, idx_t read_size) {
+		if (ptr + read_size > end_ptr) {
+			throw SerializationException("Failed to deserialize: not enough data in buffer to fulfill read request");
+		}
+		memcpy(buffer, ptr, read_size);
+		ptr += read_size;
+	}
+
+	// Set the 'tag' of the property to read
+	void SetTag(const char *tag) final;
+
+	//===--------------------------------------------------------------------===//
+	// Nested Types Hooks
+	//===--------------------------------------------------------------------===//
+	void OnObjectBegin() final;
+	void OnObjectEnd() final;
+	idx_t OnListBegin() final;
+	void OnListEnd() final;
+	idx_t OnMapBegin() final;
+	void OnMapEnd() final;
+	void OnMapEntryBegin() final;
+	void OnMapEntryEnd() final;
+	void OnMapKeyBegin() final;
+	void OnMapValueBegin() final;
+	bool OnOptionalBegin() final;
+
+	void OnPairBegin() final;
+	void OnPairKeyBegin() final;
+	void OnPairValueBegin() final;
+	void OnPairEnd() final;
+
+	//===--------------------------------------------------------------------===//
+	// Primitive Types
+	//===--------------------------------------------------------------------===//
+	bool ReadBool() final;
+	int8_t ReadSignedInt8() final;
+	uint8_t ReadUnsignedInt8() final;
+	int16_t ReadSignedInt16() final;
+	uint16_t ReadUnsignedInt16() final;
+	int32_t ReadSignedInt32() final;
+	uint32_t ReadUnsignedInt32() final;
+	int64_t ReadSignedInt64() final;
+	uint64_t ReadUnsignedInt64() final;
+	float ReadFloat() final;
+	double ReadDouble() final;
+	string ReadString() final;
+	interval_t ReadInterval() final;
+	hugeint_t ReadHugeInt() final;
+	void ReadDataPtr(data_ptr_t &ptr, idx_t count) final;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp

@@ -0,0 +1,92 @@
+#pragma once
+
+#include "duckdb/common/serializer/format_serializer.hpp"
+
+namespace duckdb {
+
+struct BinarySerializer : public FormatSerializer {
+
+private:
+	struct State {
+		// how many fields are present in the object
+		uint32_t field_count;
+		// the size of the object
+		uint64_t size;
+		// the offset of the object start in the buffer
+		uint64_t offset;
+	};
+
+	const char *current_tag;
+
+	vector<data_t> data;
+	vector<State> stack;
+
+	template <class T>
+	void Write(T element) {
+		static_assert(std::is_trivially_destructible<T>(), "Write element must be trivially destructible");
+		WriteData((const_data_ptr_t)&element, sizeof(T));
+	}
+	void WriteData(const_data_ptr_t buffer, idx_t write_size) {
+		data.insert(data.end(), buffer, buffer + write_size);
+		stack.back().size += write_size;
+	}
+
+	explicit BinarySerializer() {
+		serialize_enum_as_string = false;
+	}
+
+public:
+	template <class T>
+	static vector<data_t> Serialize(T &obj) {
+		BinarySerializer serializer;
+		serializer.OnObjectBegin();
+		obj.FormatSerialize(serializer);
+		serializer.OnObjectEnd();
+		return std::move(serializer.data);
+	}
+
+	void SetTag(const char *tag) final;
+
+	//===--------------------------------------------------------------------===//
+	// Nested Types Hooks
+	//===--------------------------------------------------------------------===//
+	void OnOptionalBegin(bool present) final;
+	void OnListBegin(idx_t count) final;
+	void OnListEnd(idx_t count) final;
+	void OnMapBegin(idx_t count) final;
+	void OnMapEntryBegin() final;
+	void OnMapEntryEnd() final;
+	void OnMapKeyBegin() final;
+	void OnMapValueBegin() final;
+	void OnMapEnd(idx_t count) final;
+	void OnObjectBegin() final;
+	void OnObjectEnd() final;
+	void OnPairBegin() final;
+	void OnPairKeyBegin() final;
+	void OnPairValueBegin() final;
+	void OnPairEnd() final;
+
+	//===--------------------------------------------------------------------===//
+	// Primitive Types
+	//===--------------------------------------------------------------------===//
+	void WriteNull() final;
+	void WriteValue(uint8_t value) final;
+	void WriteValue(int8_t value) final;
+	void WriteValue(uint16_t value) final;
+	void WriteValue(int16_t value) final;
+	void WriteValue(uint32_t value) final;
+	void WriteValue(int32_t value) final;
+	void WriteValue(uint64_t value) final;
+	void WriteValue(int64_t value) final;
+	void WriteValue(hugeint_t value) final;
+	void WriteValue(float value) final;
+	void WriteValue(double value) final;
+	void WriteValue(interval_t value) final;
+	void WriteValue(const string_t value) final;
+	void WriteValue(const string &value) final;
+	void WriteValue(const char *value) final;
+	void WriteValue(bool value) final;
+	void WriteDataPtr(const_data_ptr_t ptr, idx_t count) final;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/format_deserializer.hpp

@@ -10,7 +10,7 @@
 
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/serializer.hpp"
-#include "duckdb/common/serializer/enum_serializer.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/serializer/serialization_traits.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/string_type.hpp"
@@ -294,8 +294,12 @@ private:
 	// Deserialize a Enum
 	template <typename T = void>
 	inline typename std::enable_if<std::is_enum<T>::value, T>::type Read() {
-		auto str = ReadString();
-		return EnumSerializer::StringToEnum<T>(str.c_str());
+		if (deserialize_enum_from_string) {
+			auto str = ReadString();
+			return EnumUtil::FromString<T>(str.c_str());
+		} else {
+			return (T)Read<typename std::underlying_type<T>::type>();
+		}
 	}
 
 	// Deserialize a interval_t

package/src/duckdb/src/include/duckdb/common/serializer/format_serializer.hpp

@@ -10,7 +10,7 @@
 
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/serializer.hpp"
-#include "duckdb/common/serializer/enum_serializer.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/serializer/serialization_traits.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/string_type.hpp"
@@ -39,7 +39,7 @@ public:
 		SetTag(tag);
 		if (serialize_enum_as_string) {
 			// Use the enum serializer to lookup tostring function
-			auto str = EnumSerializer::EnumToString(value);
+			auto str = EnumUtil::ToChars(value);
 			WriteValue(str);
 		} else {
 			// Use the underlying type

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_collection.hpp

@@ -229,7 +229,7 @@ private:
 	//! The number of entries stored in the TupleDataCollection
 	idx_t count;
 	//! The data segments of the TupleDataCollection
-	vector<TupleDataSegment> segments;
+	unsafe_vector<TupleDataSegment> segments;
 	//! The set of scatter functions
 	vector<TupleDataScatterFunction> scatter_functions;
 	//! The set of gather functions

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_segment.hpp

@@ -109,7 +109,7 @@ public:
 	//! The allocator for this segment
 	shared_ptr<TupleDataAllocator> allocator;
 	//! The chunks of this segment
-	vector<TupleDataChunk> chunks;
+	unsafe_vector<TupleDataChunk> chunks;
 	//! The tuple count of this segment
 	idx_t count;
 

package/src/duckdb/src/include/duckdb/common/types.hpp

@@ -457,6 +457,7 @@ struct AggregateStateType {
 	DUCKDB_API static const aggregate_state_t &GetStateType(const LogicalType &type);
 };
 
+// **DEPRECATED**: Use EnumUtil directly instead.
 DUCKDB_API string LogicalTypeIdToString(LogicalTypeId type);
 
 DUCKDB_API LogicalTypeId TransformStringToLogicalTypeId(const string &str);

package/src/duckdb/src/include/duckdb/common/vector.hpp

@@ -10,22 +10,31 @@
 
 #include "duckdb/common/assert.hpp"
 #include "duckdb/common/typedefs.hpp"
+#include "duckdb/common/likely.hpp"
+#include "duckdb/common/exception.hpp"
 #include <vector>
 
 namespace duckdb {
 
-// TODO: inline this, needs changes to 'exception.hpp' and other headers to avoid circular dependency
-void AssertIndexInBounds(idx_t index, idx_t size);
-
-template <class _Tp, class _Allocator = std::allocator<_Tp>>
-class vector : public std::vector<_Tp, _Allocator> {
+template <class _Tp, bool SAFE = true>
+class vector : public std::vector<_Tp, std::allocator<_Tp>> {
 public:
-	using original = std::vector<_Tp, _Allocator>;
+	using original = std::vector<_Tp, std::allocator<_Tp>>;
 	using original::original;
 	using size_type = typename original::size_type;
 	using const_reference = typename original::const_reference;
 	using reference = typename original::reference;
 
+	static inline void AssertIndexInBounds(idx_t index, idx_t size) {
+#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
+		return;
+#else
+		if (DUCKDB_UNLIKELY(index >= size)) {
+			throw InternalException("Attempted to access index %ld within vector of size %ld", index, size);
+		}
+#endif
+	}
+
 #ifdef DUCKDB_CLANG_TIDY
 	// This is necessary to tell clang-tidy that it reinitializes the variable after a move
 	[[clang::reinitializes]]
@@ -40,19 +49,57 @@ public:
 	vector() = default;
 	vector(original &&other) : original(std::move(other)) {
 	}
+	template <bool _SAFE>
+	vector(vector<_Tp, _SAFE> &&other) : original(std::move(other)) {
+	}
 
-	typename original::reference operator[](typename original::size_type __n) {
-#ifdef DEBUG
-		AssertIndexInBounds(__n, original::size());
-#endif
+	template <bool _SAFE = false>
+	inline typename original::reference get(typename original::size_type __n) {
+		if (_SAFE) {
+			AssertIndexInBounds(__n, original::size());
+		}
 		return original::operator[](__n);
 	}
-	typename original::const_reference operator[](typename original::size_type __n) const {
-#ifdef DEBUG
-		AssertIndexInBounds(__n, original::size());
-#endif
+
+	template <bool _SAFE = false>
+	inline typename original::const_reference get(typename original::size_type __n) const {
+		if (_SAFE) {
+			AssertIndexInBounds(__n, original::size());
+		}
 		return original::operator[](__n);
 	}
+
+	typename original::reference operator[](typename original::size_type __n) {
+		return get<SAFE>(__n);
+	}
+	typename original::const_reference operator[](typename original::size_type __n) const {
+		return get<SAFE>(__n);
+	}
+
+	typename original::reference front() {
+		return get<SAFE>(0);
+	}
+
+	typename original::const_reference front() const {
+		return get<SAFE>(0);
+	}
+
+	typename original::reference back() {
+		if (original::empty()) {
+			throw InternalException("'back' called on an empty vector!");
+		}
+		return get<SAFE>(original::size() - 1);
+	}
+
+	typename original::const_reference back() const {
+		if (original::empty()) {
+			throw InternalException("'back' called on an empty vector!");
+		}
+		return get<SAFE>(original::size() - 1);
+	}
 };
 
+template <typename T>
+using unsafe_vector = vector<T, false>;
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/aggregate_hashtable.hpp

@@ -102,9 +102,10 @@ public:
 	//! Add the given data to the HT, computing the aggregates grouped by the
 	//! data in the group chunk. When resize = true, aggregates will not be
 	//! computed but instead just assigned.
-	idx_t AddChunk(AggregateHTAppendState &state, DataChunk &groups, DataChunk &payload, const vector<idx_t> &filter);
+	idx_t AddChunk(AggregateHTAppendState &state, DataChunk &groups, DataChunk &payload,
+	               const unsafe_vector<idx_t> &filter);
 	idx_t AddChunk(AggregateHTAppendState &state, DataChunk &groups, Vector &group_hashes, DataChunk &payload,
-	               const vector<idx_t> &filter);
+	               const unsafe_vector<idx_t> &filter);
 	idx_t AddChunk(AggregateHTAppendState &state, DataChunk &groups, DataChunk &payload, AggregateType filter);
 
 	//! Scan the HT starting from the scan_position until the result and group

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp

@@ -21,7 +21,7 @@ public:
 
 public:
 	// The indices of the aggregates that are distinct
-	vector<idx_t> indices;
+	unsafe_vector<idx_t> indices;
 	// The amount of radix_tables that are occupied
 	idx_t table_count;
 	//! Occupied tables, not equal to indices if aggregates share input data
@@ -34,7 +34,7 @@ public:
 
 public:
 	static unique_ptr<DistinctAggregateCollectionInfo> Create(vector<unique_ptr<Expression>> &aggregates);
-	const vector<idx_t> &Indices() const;
+	const unsafe_vector<idx_t> &Indices() const;
 	bool AnyDistinct() const;
 
 private:

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp

@@ -42,7 +42,7 @@ public:
 	const vector<vector<idx_t>> &GetGroupingFunctions() const;
 
 	void InitializeGroupby(vector<unique_ptr<Expression>> groups, vector<unique_ptr<Expression>> expressions,
-	                       vector<vector<idx_t>> grouping_functions);
+	                       vector<unsafe_vector<idx_t>> grouping_functions);
 
 	//! Initialize a GroupedAggregateData object for use with distinct aggregates
 	void InitializeDistinct(const unique_ptr<Expression> &aggregate, const vector<unique_ptr<Expression>> *groups_p);
@@ -50,7 +50,7 @@ public:
 private:
 	void InitializeDistinctGroups(const vector<unique_ptr<Expression>> *groups);
 	void InitializeGroupbyGroups(vector<unique_ptr<Expression>> groups);
-	void SetGroupingFunctions(vector<vector<idx_t>> &functions);
+	void SetGroupingFunctions(vector<unsafe_vector<idx_t>> &functions);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp

@@ -67,7 +67,7 @@ public:
 	                      vector<unique_ptr<Expression>> groups, idx_t estimated_cardinality);
 	PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
 	                      vector<unique_ptr<Expression>> groups, vector<GroupingSet> grouping_sets,
-	                      vector<vector<idx_t>> grouping_functions, idx_t estimated_cardinality);
+	                      vector<unsafe_vector<idx_t>> grouping_functions, idx_t estimated_cardinality);
 
 	//! The grouping sets
 	GroupedAggregateData grouped_aggregate_data;
@@ -80,8 +80,8 @@ public:
 	vector<LogicalType> input_group_types;
 
 	// Filters given to Sink and friends
-	vector<idx_t> non_distinct_filter;
-	vector<idx_t> distinct_filter;
+	unsafe_vector<idx_t> non_distinct_filter;
+	unsafe_vector<idx_t> distinct_filter;
 
 	unordered_map<Expression *, size_t> filter_indexes;
 

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp

@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/persistent/physical_batch_copy_to_file.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/parser/parsed_data/copy_info.hpp"
+#include "duckdb/function/copy_function.hpp"
+#include "duckdb/common/file_system.hpp"
+#include "duckdb/common/filename_pattern.hpp"
+
+namespace duckdb {
+
+//! Copy the contents of a query into a table
+class PhysicalBatchCopyToFile : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::BATCH_COPY_TO_FILE;
+
+public:
+	PhysicalBatchCopyToFile(vector<LogicalType> types, CopyFunction function, unique_ptr<FunctionData> bind_data,
+	                        idx_t estimated_cardinality);
+
+	CopyFunction function;
+	unique_ptr<FunctionData> bind_data;
+	string file_path;
+	bool use_tmp_file;
+
+public:
+	// Source interface
+	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
+
+	bool IsSource() const override {
+		return true;
+	}
+
+public:
+	// Sink interface
+	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
+	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
+	                          GlobalSinkState &gstate) const override;
+	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
+	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
+	void NextBatch(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p) const override;
+
+	bool RequiresBatchIndex() const override {
+		return true;
+	}
+
+	bool IsSink() const override {
+		return true;
+	}
+
+	bool ParallelSink() const override {
+		return true;
+	}
+
+private:
+	void PrepareBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t batch_index,
+	                      unique_ptr<ColumnDataCollection> collection) const;
+	void FlushBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index) const;
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_copy_to_file.hpp

@@ -67,5 +67,7 @@ public:
 	bool ParallelSink() const override {
 		return per_thread_output || partition_output || parallel;
 	}
+
+	static void MoveTmpFile(ClientContext &context, const string &tmp_file_path);
 };
 } // namespace duckdb