duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

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

@@ -41,48 +41,32 @@ public:
 
 class WindowAggregator {
 public:
-	WindowAggregator(AggregateObject aggr, const LogicalType &result_type_p, const WindowExcludeMode exclude_mode_p,
-	                 idx_t partition_count);
+	WindowAggregator(AggregateObject aggr, const vector<LogicalType> &arg_types_p, const LogicalType &result_type_p,
+	                 const WindowExcludeMode exclude_mode_p);
 	virtual ~WindowAggregator();
 
-	//	Access
-	const DataChunk &GetInputs() const {
-		return inputs;
-	}
-	const ValidityMask &GetFilterMask() const {
-		return filter_mask;
-	}
+	//	Threading states
+	virtual unique_ptr<WindowAggregatorState> GetGlobalState(idx_t group_count,
+	                                                         const ValidityMask &partition_mask) const;
+	virtual unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const = 0;
 
 	//	Build
-	virtual void Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered);
-	virtual void Finalize(const FrameStats &stats);
+	virtual void Sink(WindowAggregatorState &gstate, WindowAggregatorState &lstate, DataChunk &arg_chunk,
+	                  idx_t input_idx, optional_ptr<SelectionVector> filter_sel, idx_t filtered);
+	virtual void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, const FrameStats &stats);
 
 	//	Probe
-	virtual unique_ptr<WindowAggregatorState> GetLocalState() const = 0;
-	virtual void Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count,
-	                      idx_t row_idx) const = 0;
+	virtual void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
+	                      Vector &result, idx_t count, idx_t row_idx) const = 0;
 
 	//! A description of the aggregator
 	const AggregateObject aggr;
+	//! The argument types for the function
+	const vector<LogicalType> arg_types;
 	//! The result type of the window function
 	const LogicalType result_type;
-	//! The cardinality of the partition
-	const idx_t partition_count;
 	//! The size of a single aggregate state
 	const idx_t state_size;
-
-protected:
-	//! Partition data chunk
-	DataChunk inputs;
-
-	//! The filtered rows in inputs.
-	vector<validity_t> filter_bits;
-	ValidityMask filter_mask;
-	idx_t filter_pos;
-	//! The state used by the aggregator to build.
-	unique_ptr<WindowAggregatorState> gstate;
-
-public:
 	//! The window exclusion clause
 	const WindowExcludeMode exclude_mode;
 };
@@ -90,145 +74,92 @@ public:
 // Used for validation
 class WindowNaiveAggregator : public WindowAggregator {
 public:
-	WindowNaiveAggregator(AggregateObject aggr, const LogicalType &result_type_p,
-	                      const WindowExcludeMode exclude_mode_p, idx_t partition_count);
+	WindowNaiveAggregator(AggregateObject aggr, const vector<LogicalType> &arg_types_p,
+	                      const LogicalType &result_type_p, const WindowExcludeMode exclude_mode);
 	~WindowNaiveAggregator() override;
 
-	unique_ptr<WindowAggregatorState> GetLocalState() const override;
-	void Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count,
-	              idx_t row_idx) const override;
+	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
+	void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
+	              Vector &result, idx_t count, idx_t row_idx) const override;
 };
 
 class WindowConstantAggregator : public WindowAggregator {
 public:
-	WindowConstantAggregator(AggregateObject aggr, const LogicalType &result_type_p, const ValidityMask &partition_mask,
-	                         WindowExcludeMode exclude_mode_p, const idx_t count);
+	WindowConstantAggregator(AggregateObject aggr, const vector<LogicalType> &arg_types_p,
+	                         const LogicalType &result_type_p, WindowExcludeMode exclude_mode_p);
 	~WindowConstantAggregator() override {
 	}
 
-	void Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered) override;
-	void Finalize(const FrameStats &stats) override;
-
-	unique_ptr<WindowAggregatorState> GetLocalState() const override;
-	void Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count,
-	              idx_t row_idx) const override;
-
-private:
-	void AggregateInit();
-	void AggegateFinal(Vector &result, idx_t rid);
-
-	//! Partition starts
-	vector<idx_t> partition_offsets;
-	//! Aggregate results
-	unique_ptr<Vector> results;
-	//! The current result partition being built/read
-	idx_t partition;
-	//! The current input row being built/read
-	idx_t row;
-	//! Data pointer that contains a single state, used for intermediate window segment aggregation
-	vector<data_t> state;
-	//! A vector of pointers to "state", used for intermediate window segment aggregation
-	Vector statep;
-	//! Reused result state container for the window functions
-	Vector statef;
+	unique_ptr<WindowAggregatorState> GetGlobalState(idx_t group_count,
+	                                                 const ValidityMask &partition_mask) const override;
+	void Sink(WindowAggregatorState &gstate, WindowAggregatorState &lstate, DataChunk &arg_chunk, idx_t input_idx,
+	          optional_ptr<SelectionVector> filter_sel, idx_t filtered) override;
+	void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, const FrameStats &stats) override;
+
+	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
+	void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
+	              Vector &result, idx_t count, idx_t row_idx) const override;
 };
 
 class WindowCustomAggregator : public WindowAggregator {
 public:
-	WindowCustomAggregator(AggregateObject aggr, const LogicalType &result_type_p,
-	                       const WindowExcludeMode exclude_mode_p, idx_t partition_count);
+	WindowCustomAggregator(AggregateObject aggr, const vector<LogicalType> &arg_types_p,
+	                       const LogicalType &result_type_p, const WindowExcludeMode exclude_mode);
 	~WindowCustomAggregator() override;
 
-	void Finalize(const FrameStats &stats) override;
-
-	unique_ptr<WindowAggregatorState> GetLocalState() const override;
-	void Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count,
-	              idx_t row_idx) const override;
+	unique_ptr<WindowAggregatorState> GetGlobalState(idx_t group_count,
+	                                                 const ValidityMask &partition_mask) const override;
+	void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, const FrameStats &stats) override;
 
-	//! Partition description
-	unique_ptr<WindowPartitionInput> partition_input;
-
-	//! Data pointer that contains a single state, used for global custom window state
-	unique_ptr<WindowAggregatorState> gstate;
+	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
+	void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
+	              Vector &result, idx_t count, idx_t row_idx) const override;
 };
 
 class WindowSegmentTree : public WindowAggregator {
 
 public:
-	WindowSegmentTree(AggregateObject aggr, const LogicalType &result_type, WindowAggregationMode mode_p,
-	                  const WindowExcludeMode exclude_mode_p, idx_t count);
-	~WindowSegmentTree() override;
+	WindowSegmentTree(AggregateObject aggr, const vector<LogicalType> &arg_types_p, const LogicalType &result_type_p,
+	                  WindowAggregationMode mode_p, const WindowExcludeMode exclude_mode);
 
-	void Finalize(const FrameStats &stats) override;
+	unique_ptr<WindowAggregatorState> GetGlobalState(idx_t group_count,
+	                                                 const ValidityMask &partition_mask) const override;
+	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
+	void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, const FrameStats &stats) override;
 
-	unique_ptr<WindowAggregatorState> GetLocalState() const override;
-	void Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count,
-	              idx_t row_idx) const override;
+	void Evaluate(const WindowAggregatorState &gstate, WindowAggregatorState &lstate, const DataChunk &bounds,
+	              Vector &result, idx_t count, idx_t row_idx) const override;
 
 public:
-	void ConstructTree();
-
 	//! Use the combine API, if available
 	inline bool UseCombineAPI() const {
 		return mode < WindowAggregationMode::SEPARATE;
 	}
 
-	//! The actual window segment tree: an array of aggregate states that represent all the intermediate nodes
-	unsafe_unique_array<data_t> levels_flat_native;
-	//! For each level, the starting location in the levels_flat_native array
-	vector<idx_t> levels_flat_start;
-
-	//! The total number of internal nodes of the tree, stored in levels_flat_native
-	idx_t internal_nodes;
-
 	//! Use the combine API, if available
 	WindowAggregationMode mode;
-
-	// TREE_FANOUT needs to cleanly divide STANDARD_VECTOR_SIZE
-	static constexpr idx_t TREE_FANOUT = 16;
 };
 
 class WindowDistinctAggregator : public WindowAggregator {
 public:
-	using GlobalSortStatePtr = unique_ptr<GlobalSortState>;
-	class DistinctSortTree;
-
-	WindowDistinctAggregator(AggregateObject aggr, const LogicalType &result_type,
-	                         const WindowExcludeMode exclude_mode_p, idx_t count, ClientContext &context);
-	~WindowDistinctAggregator() override;
+	WindowDistinctAggregator(AggregateObject aggr, const vector<LogicalType> &arg_types_p,
+	                         const LogicalType &result_type_p, const WindowExcludeMode exclude_mode_p,
+	                         ClientContext &context);
 
 	//	Build
-	void Sink(DataChunk &args_chunk, SelectionVector *filter_sel, idx_t filtered) override;
-	void Finalize(const FrameStats &stats) override;
+	unique_ptr<WindowAggregatorState> GetGlobalState(idx_t group_count,
+	                                                 const ValidityMask &partition_mask) const override;
+	void Sink(WindowAggregatorState &gsink, WindowAggregatorState &lstate, DataChunk &arg_chunk, idx_t input_idx,
+	          optional_ptr<SelectionVector> filter_sel, idx_t filtered) override;
+	void Finalize(WindowAggregatorState &gstate, WindowAggregatorState &lstate, const FrameStats &stats) override;
 
 	//	Evaluate
-	unique_ptr<WindowAggregatorState> GetLocalState() const override;
-	void Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count,
-	              idx_t row_idx) const override;
+	unique_ptr<WindowAggregatorState> GetLocalState(const WindowAggregatorState &gstate) const override;
+	void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds,
+	              Vector &result, idx_t count, idx_t row_idx) const override;
 
+	//! Context for sorting
 	ClientContext &context;
-	ArenaAllocator allocator;
-
-	//	Single threaded sorting for now
-	GlobalSortStatePtr global_sort;
-	LocalSortState local_sort;
-	idx_t payload_pos;
-	idx_t memory_per_thread;
-
-	vector<LogicalType> payload_types;
-	DataChunk sort_chunk;
-	DataChunk payload_chunk;
-
-	//! The merge sort tree for the aggregate.
-	unique_ptr<DistinctSortTree> merge_sort_tree;
-
-	//! The actual window segment tree: an array of aggregate states that represent all the intermediate nodes
-	unsafe_unique_array<data_t> levels_flat_native;
-	//! For each level, the starting location in the levels_flat_native array
-	vector<idx_t> levels_flat_start;
-
-	//! The total number of internal nodes of the tree, stored in levels_flat_native
-	idx_t internal_nodes;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/aggregate_function.hpp

@@ -42,9 +42,9 @@ struct WindowPartitionInput {
 };
 
 //! The type used for sizing hashed aggregate function states
-typedef idx_t (*aggregate_size_t)();
+typedef idx_t (*aggregate_size_t)(const AggregateFunction &function);
 //! The type used for initializing hashed aggregate function states
-typedef void (*aggregate_initialize_t)(data_ptr_t state);
+typedef void (*aggregate_initialize_t)(const AggregateFunction &function, data_ptr_t state);
 //! The type used for updating hashed aggregate functions
 typedef void (*aggregate_update_t)(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count,
                                    Vector &state, idx_t count);
@@ -79,6 +79,21 @@ typedef void (*aggregate_serialize_t)(Serializer &serializer, const optional_ptr
                                       const AggregateFunction &function);
 typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(Deserializer &deserializer, AggregateFunction &function);
 
+struct AggregateFunctionInfo {
+	DUCKDB_API virtual ~AggregateFunctionInfo();
+
+	template <class TARGET>
+	TARGET &Cast() {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+};
+
 class AggregateFunction : public BaseScalarFunction { // NOLINT: work-around bug in clang-tidy
 public:
 	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
@@ -162,6 +177,8 @@ public:
 	aggregate_deserialize_t deserialize;
 	//! Whether or not the aggregate is order dependent
 	AggregateOrderDependent order_dependent;
+	//! Additional function info, passed to the bind
+	shared_ptr<AggregateFunctionInfo> function_info;
 
 	bool operator==(const AggregateFunction &rhs) const {
 		return state_size == rhs.state_size && initialize == rhs.initialize && update == rhs.update &&
@@ -211,12 +228,12 @@ public:
 
 public:
 	template <class STATE>
-	static idx_t StateSize() {
+	static idx_t StateSize(const AggregateFunction &) {
 		return sizeof(STATE);
 	}
 
 	template <class STATE, class OP>
-	static void StateInitialize(data_ptr_t state) {
+	static void StateInitialize(const AggregateFunction &, data_ptr_t state) {
 		OP::Initialize(*reinterpret_cast<STATE *>(state));
 	}
 

package/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp

@@ -164,7 +164,7 @@ private:
 	                                            const LogicalType &target);
 	static BoundCastInfo UnionCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo UUIDCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-
+	static BoundCastInfo VarintCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo ImplicitToUnionCast(BindCastInput &input, const LogicalType &source,
 	                                         const LogicalType &target);
 };

package/src/duckdb/src/include/duckdb/function/compression/compression.hpp

@@ -15,52 +15,52 @@ namespace duckdb {
 
 struct ConstantFun {
 	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
+	static bool TypeIsSupported(const PhysicalType physical_type);
 };
 
 struct UncompressedFun {
 	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
+	static bool TypeIsSupported(const PhysicalType physical_type);
 };
 
 struct RLEFun {
 	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
+	static bool TypeIsSupported(const PhysicalType physical_type);
 };
 
 struct BitpackingFun {
 	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
+	static bool TypeIsSupported(const PhysicalType physical_type);
 };
 
 struct DictionaryCompressionFun {
 	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
+	static bool TypeIsSupported(const PhysicalType physical_type);
 };
 
 struct ChimpCompressionFun {
 	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
+	static bool TypeIsSupported(const PhysicalType physical_type);
 };
 
 struct PatasCompressionFun {
 	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
+	static bool TypeIsSupported(const PhysicalType physical_type);
 };
 
 struct AlpCompressionFun {
 	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
+	static bool TypeIsSupported(const PhysicalType physical_type);
 };
 
 struct AlpRDCompressionFun {
 	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
+	static bool TypeIsSupported(const PhysicalType physical_type);
 };
 
 struct FSSTFun {
 	static CompressionFunction GetFunction(PhysicalType type);
-	static bool TypeIsSupported(PhysicalType type);
+	static bool TypeIsSupported(const PhysicalType physical_type);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/compression_function.hpp

@@ -9,12 +9,12 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
-#include "duckdb/function/function.hpp"
 #include "duckdb/common/enums/compression_type.hpp"
 #include "duckdb/common/map.hpp"
-#include "duckdb/storage/storage_info.hpp"
 #include "duckdb/common/mutex.hpp"
+#include "duckdb/function/function.hpp"
 #include "duckdb/storage/data_pointer.hpp"
+#include "duckdb/storage/storage_info.hpp"
 
 namespace duckdb {
 class DatabaseInstance;
@@ -26,9 +26,30 @@ struct ColumnSegmentState;
 
 struct ColumnFetchState;
 struct ColumnScanState;
+struct PrefetchState;
 struct SegmentScanState;
 
+class CompressionInfo {
+public:
+	explicit CompressionInfo(const idx_t block_size) : block_size(block_size) {
+	}
+
+public:
+	//! The size below which the segment is compacted on flushing.
+	idx_t GetCompactionFlushLimit() const {
+		return block_size / 5 * 4;
+	}
+	//! The block size for blocks using this compression.
+	idx_t GetBlockSize() const {
+		return block_size;
+	}
+
+private:
+	idx_t block_size;
+};
+
 struct AnalyzeState {
+	explicit AnalyzeState(const CompressionInfo &info) : info(info) {};
 	virtual ~AnalyzeState() {
 	}
 
@@ -42,9 +63,12 @@ struct AnalyzeState {
 		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
+
+	CompressionInfo info;
 };
 
 struct CompressionState {
+	explicit CompressionState(const CompressionInfo &info) : info(info) {};
 	virtual ~CompressionState() {
 	}
 
@@ -58,6 +82,8 @@ struct CompressionState {
 		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
+
+	CompressionInfo info;
 };
 
 struct CompressedSegmentState {
@@ -128,6 +154,7 @@ typedef void (*compression_compress_finalize_t)(CompressionState &state);
 //===--------------------------------------------------------------------===//
 // Uncompress / Scan
 //===--------------------------------------------------------------------===//
+typedef void (*compression_init_prefetch_t)(ColumnSegment &segment, PrefetchState &prefetch_state);
 typedef unique_ptr<SegmentScanState> (*compression_init_segment_scan_t)(ColumnSegment &segment);
 
 //! Function prototype used for reading an entire vector (STANDARD_VECTOR_SIZE)
@@ -178,13 +205,14 @@ public:
 	                    compression_revert_append_t revert_append = nullptr,
 	                    compression_serialize_state_t serialize_state = nullptr,
 	                    compression_deserialize_state_t deserialize_state = nullptr,
-	                    compression_cleanup_state_t cleanup_state = nullptr)
+	                    compression_cleanup_state_t cleanup_state = nullptr,
+	                    compression_init_prefetch_t init_prefetch = nullptr)
 	    : type(type), data_type(data_type), init_analyze(init_analyze), analyze(analyze), final_analyze(final_analyze),
 	      init_compression(init_compression), compress(compress), compress_finalize(compress_finalize),
-	      init_scan(init_scan), scan_vector(scan_vector), scan_partial(scan_partial), fetch_row(fetch_row), skip(skip),
-	      init_segment(init_segment), init_append(init_append), append(append), finalize_append(finalize_append),
-	      revert_append(revert_append), serialize_state(serialize_state), deserialize_state(deserialize_state),
-	      cleanup_state(cleanup_state) {
+	      init_prefetch(init_prefetch), init_scan(init_scan), scan_vector(scan_vector), scan_partial(scan_partial),
+	      fetch_row(fetch_row), skip(skip), init_segment(init_segment), init_append(init_append), append(append),
+	      finalize_append(finalize_append), revert_append(revert_append), serialize_state(serialize_state),
+	      deserialize_state(deserialize_state), cleanup_state(cleanup_state) {
 	}
 
 	//! Compression type
@@ -213,6 +241,8 @@ public:
 	//! compress_finalize is called after
 	compression_compress_finalize_t compress_finalize;
 
+	//! Initialize prefetch state with required I/O data to scan this segment
+	compression_init_prefetch_t init_prefetch;
 	//! init_scan is called to set up the scan state
 	compression_init_segment_scan_t init_scan;
 	//! scan_vector scans an entire vector using the scan state

package/src/duckdb/src/include/duckdb/function/copy_function.hpp

@@ -74,6 +74,13 @@ struct CopyFunctionBindInput {
 	string file_extension;
 };
 
+struct CopyToSelectInput {
+	ClientContext &context;
+	case_insensitive_map_t<vector<Value>> &options;
+	vector<unique_ptr<Expression>> select_list;
+	CopyToType copy_to_type;
+};
+
 enum class CopyFunctionExecutionMode { REGULAR_COPY_TO_FILE, PARALLEL_COPY_TO_FILE, BATCH_COPY_TO_FILE };
 
 typedef BoundStatement (*copy_to_plan_t)(Binder &binder, CopyStatement &stmt);
@@ -105,25 +112,31 @@ typedef void (*copy_flush_batch_t)(ClientContext &context, FunctionData &bind_da
                                    PreparedBatchData &batch);
 typedef idx_t (*copy_desired_batch_size_t)(ClientContext &context, FunctionData &bind_data);
 
-typedef idx_t (*copy_file_size_bytes_t)(GlobalFunctionData &gstate);
+typedef bool (*copy_rotate_files_t)(FunctionData &bind_data, const optional_idx &file_size_bytes);
+
+typedef bool (*copy_rotate_next_file_t)(GlobalFunctionData &gstate, FunctionData &bind_data,
+                                        const optional_idx &file_size_bytes);
 
-enum class CopyTypeSupport { SUPPORTED, LOSSY, UNSUPPORTED };
+typedef vector<unique_ptr<Expression>> (*copy_to_select_t)(CopyToSelectInput &input);
 
-typedef CopyTypeSupport (*copy_supports_type_t)(const LogicalType &type);
+enum class CopyFunctionReturnType : uint8_t { CHANGED_ROWS = 0, CHANGED_ROWS_AND_FILE_LIST = 1 };
+vector<string> GetCopyFunctionReturnNames(CopyFunctionReturnType return_type);
+vector<LogicalType> GetCopyFunctionReturnLogicalTypes(CopyFunctionReturnType return_type);
 
 class CopyFunction : public Function { // NOLINT: work-around bug in clang-tidy
 public:
 	explicit CopyFunction(const string &name)
-	    : Function(name), plan(nullptr), copy_to_bind(nullptr), copy_to_initialize_local(nullptr),
-	      copy_to_initialize_global(nullptr), copy_to_sink(nullptr), copy_to_combine(nullptr),
-	      copy_to_finalize(nullptr), execution_mode(nullptr), prepare_batch(nullptr), flush_batch(nullptr),
-	      desired_batch_size(nullptr), file_size_bytes(nullptr), serialize(nullptr), deserialize(nullptr),
-	      supports_type(nullptr), copy_from_bind(nullptr) {
+	    : Function(name), plan(nullptr), copy_to_select(nullptr), copy_to_bind(nullptr),
+	      copy_to_initialize_local(nullptr), copy_to_initialize_global(nullptr), copy_to_sink(nullptr),
+	      copy_to_combine(nullptr), copy_to_finalize(nullptr), execution_mode(nullptr), prepare_batch(nullptr),
+	      flush_batch(nullptr), desired_batch_size(nullptr), rotate_files(nullptr), rotate_next_file(nullptr),
+	      serialize(nullptr), deserialize(nullptr), copy_from_bind(nullptr) {
 	}
 
 	//! Plan rewrite copy function
 	copy_to_plan_t plan;
 
+	copy_to_select_t copy_to_select;
 	copy_to_bind_t copy_to_bind;
 	copy_to_initialize_local_t copy_to_initialize_local;
 	copy_to_initialize_global_t copy_to_initialize_global;
@@ -135,13 +148,13 @@ public:
 	copy_prepare_batch_t prepare_batch;
 	copy_flush_batch_t flush_batch;
 	copy_desired_batch_size_t desired_batch_size;
-	copy_file_size_bytes_t file_size_bytes;
+
+	copy_rotate_files_t rotate_files;
+	copy_rotate_next_file_t rotate_next_file;
 
 	copy_to_serialize_t serialize;
 	copy_to_deserialize_t deserialize;
 
-	copy_supports_type_t supports_type;
-
 	copy_from_bind_t copy_from_bind;
 	TableFunction copy_from_function;
 

package/src/duckdb/src/include/duckdb/function/function_binder.hpp

@@ -57,10 +57,10 @@ public:
 	                                                     bool is_operator = false,
 	                                                     optional_ptr<Binder> binder = nullptr);
 
-	DUCKDB_API unique_ptr<BoundFunctionExpression> BindScalarFunction(ScalarFunction bound_function,
-	                                                                  vector<unique_ptr<Expression>> children,
-	                                                                  bool is_operator = false,
-	                                                                  optional_ptr<Binder> binder = nullptr);
+	DUCKDB_API unique_ptr<Expression> BindScalarFunction(ScalarFunction bound_function,
+	                                                     vector<unique_ptr<Expression>> children,
+	                                                     bool is_operator = false,
+	                                                     optional_ptr<Binder> binder = nullptr);
 
 	DUCKDB_API unique_ptr<BoundAggregateExpression>
 	BindAggregateFunction(AggregateFunction bound_function, vector<unique_ptr<Expression>> children,

package/src/duckdb/src/include/duckdb/function/function_serialization.hpp

@@ -71,6 +71,42 @@ public:
 		return result;
 	}
 
+	static bool TypeRequiresAssignment(const LogicalType &type) {
+		switch (type.id()) {
+		case LogicalTypeId::SQLNULL:
+		case LogicalTypeId::ANY:
+		case LogicalTypeId::INVALID:
+			return true;
+		case LogicalTypeId::DECIMAL:
+		case LogicalTypeId::UNION:
+		case LogicalTypeId::MAP:
+			if (!type.AuxInfo()) {
+				return true;
+			}
+			return false;
+		case LogicalTypeId::LIST:
+			if (!type.AuxInfo()) {
+				return true;
+			}
+			return TypeRequiresAssignment(ListType::GetChildType(type));
+		case LogicalTypeId::ARRAY:
+			if (!type.AuxInfo()) {
+				return true;
+			}
+			return TypeRequiresAssignment(ArrayType::GetChildType(type));
+		case LogicalTypeId::STRUCT:
+			if (!type.AuxInfo()) {
+				return true;
+			}
+			if (StructType::GetChildCount(type) == 0) {
+				return true;
+			}
+			return false;
+		default:
+			return false;
+		}
+	}
+
 	template <class FUNC, class CATALOG_ENTRY>
 	static pair<FUNC, unique_ptr<FunctionData>> Deserialize(Deserializer &deserializer, CatalogType catalog_type,
 	                                                        vector<unique_ptr<Expression>> &children,
@@ -82,7 +118,9 @@ public:
 
 		unique_ptr<FunctionData> bind_data;
 		if (has_serialize) {
+			deserializer.Set<const LogicalType &>(return_type);
 			bind_data = FunctionDeserialize<FUNC>(deserializer, function);
+			deserializer.Unset<LogicalType>();
 		} else if (function.bind) {
 			try {
 				bind_data = function.bind(context, function, children);
@@ -92,7 +130,9 @@ public:
 				                             error.RawMessage());
 			}
 		}
-		function.return_type = std::move(return_type);
+		if (TypeRequiresAssignment(function.return_type)) {
+			function.return_type = std::move(return_type);
+		}
 		return make_pair(std::move(function), std::move(bind_data));
 	}
 };