duckdb 1.3.1-dev6.0 → 1.3.1

package/src/duckdb/src/include/duckdb/catalog/catalog_set.hpp

@@ -105,7 +105,9 @@ public:
 	DUCKDB_API void ScanWithPrefix(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback,
 	                               const string &prefix);
 	DUCKDB_API void Scan(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback);
+	DUCKDB_API void ScanWithReturn(CatalogTransaction transaction, const std::function<bool(CatalogEntry &)> &callback);
 	DUCKDB_API void Scan(ClientContext &context, const std::function<void(CatalogEntry &)> &callback);
+	DUCKDB_API void ScanWithReturn(ClientContext &context, const std::function<bool(CatalogEntry &)> &callback);
 
 	template <class T>
 	vector<reference<T>> GetEntries(CatalogTransaction transaction) {

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

@@ -16,9 +16,9 @@ class Allocator;
 class BlockManager;
 struct FileHandle;
 
-enum class FileBufferType : uint8_t { BLOCK = 1, MANAGED_BUFFER = 2, TINY_BUFFER = 3 };
+enum class FileBufferType : uint8_t { BLOCK = 1, MANAGED_BUFFER = 2, TINY_BUFFER = 3, EXTERNAL_FILE = 4 };
 
-static constexpr idx_t FILE_BUFFER_TYPE_COUNT = 3;
+static constexpr idx_t FILE_BUFFER_TYPE_COUNT = 4;
 
 //! The FileBuffer represents a buffer that can be read or written to a Direct IO FileHandle.
 class FileBuffer {

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

@@ -70,7 +70,7 @@ inline
 shared_ptr<DATA_TYPE>
 make_shared_ptr(ARGS&&... args) // NOLINT: mimic std style
 {
-	return shared_ptr<DATA_TYPE>(std::make_shared<DATA_TYPE>(std::forward<ARGS>(args)...));
+	return shared_ptr<DATA_TYPE>(duckdb_base_std::make_shared<DATA_TYPE>(std::forward<ARGS>(args)...));
 }
 
 template<class DATA_TYPE, class... ARGS>
@@ -82,31 +82,31 @@ make_unsafe_uniq(ARGS&&... args) // NOLINT: mimic std style
 }
 
 template<class DATA_TYPE>
-inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, true>
+inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>, true>
 make_uniq_array(size_t n) // NOLINT: mimic std style
 {
-	return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, true>(new DATA_TYPE[n]());
+	return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>, true>(new DATA_TYPE[n]());
 }
 
 template<class DATA_TYPE>
-inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, true>
+inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>, true>
 make_uniq_array_uninitialized(size_t n) // NOLINT: mimic std style
 {
-	return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, true>(new DATA_TYPE[n]);
+	return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>, true>(new DATA_TYPE[n]);
 }
 
 template<class DATA_TYPE>
-inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, false>
+inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>, false>
 make_unsafe_uniq_array(size_t n) // NOLINT: mimic std style
 {
-	return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, false>(new DATA_TYPE[n]());
+	return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>, false>(new DATA_TYPE[n]());
 }
 
 template<class DATA_TYPE>
-inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, false>
+inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>, false>
 make_unsafe_uniq_array_uninitialized(size_t n) // NOLINT: mimic std style
 {
-	return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, false>(new DATA_TYPE[n]);
+	return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>, false>(new DATA_TYPE[n]);
 }
 
 template<class DATA_TYPE, class... ARGS>

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

@@ -15,9 +15,9 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/common/open_file_info.hpp"
+#include "duckdb/original/std/sstream.hpp"
 
 #include <iostream>
-#include <sstream>
 
 namespace duckdb {
 struct MultiFilePushdownInfo;

package/src/duckdb/src/include/duckdb/common/multi_file/multi_file_column_mapper.hpp

@@ -19,16 +19,15 @@ public:
 	MultiFileColumnMapper(ClientContext &context, MultiFileReader &multi_file_reader, MultiFileReaderData &reader_data,
 	                      const vector<MultiFileColumnDefinition> &global_columns,
 	                      const vector<ColumnIndex> &global_column_ids, optional_ptr<TableFilterSet> filters,
-	                      MultiFileList &multi_file_list, const MultiFileReaderBindData &bind_data,
-	                      const virtual_column_map_t &virtual_columns);
+	                      MultiFileList &multi_file_list, const virtual_column_map_t &virtual_columns);
 
 public:
-	ReaderInitializeType CreateMapping();
+	ReaderInitializeType CreateMapping(MultiFileColumnMappingMode mapping_mode);
 
 	void ThrowColumnNotFoundError(const string &global_column_name) const;
 
 private:
-	ResultColumnMapping CreateColumnMapping();
+	ResultColumnMapping CreateColumnMapping(MultiFileColumnMappingMode mapping_mode);
 	ResultColumnMapping CreateColumnMappingByMapper(const ColumnMapper &mapper);
 
 	unique_ptr<TableFilterSet> CreateFilters(map<idx_t, reference<TableFilter>> &filters, ResultColumnMapping &mapping);
@@ -45,7 +44,6 @@ private:
 	const vector<MultiFileColumnDefinition> &global_columns;
 	const vector<ColumnIndex> &global_column_ids;
 	optional_ptr<TableFilterSet> global_filters;
-	const MultiFileReaderBindData &bind_data;
 	const virtual_column_map_t &virtual_columns;
 };
 

package/src/duckdb/src/include/duckdb/common/multi_file/multi_file_reader.hpp

@@ -106,6 +106,13 @@ public:
 	                                     optional_ptr<MultiFileReaderGlobalState> global_state);
 
 	//! Create all required mappings from the global types/names to the file-local types/names
+	DUCKDB_API virtual ReaderInitializeType
+	CreateMapping(ClientContext &context, MultiFileReaderData &reader_data,
+	              const vector<MultiFileColumnDefinition> &global_columns, const vector<ColumnIndex> &global_column_ids,
+	              optional_ptr<TableFilterSet> filters, MultiFileList &multi_file_list,
+	              const MultiFileReaderBindData &bind_data, const virtual_column_map_t &virtual_columns,
+	              MultiFileColumnMappingMode mapping_mode);
+
 	DUCKDB_API virtual ReaderInitializeType
 	CreateMapping(ClientContext &context, MultiFileReaderData &reader_data,
 	              const vector<MultiFileColumnDefinition> &global_columns, const vector<ColumnIndex> &global_column_ids,

package/src/duckdb/src/include/duckdb/common/multi_file/multi_file_states.hpp

@@ -84,6 +84,9 @@ struct MultiFileBindData : public TableFunctionData {
 	void Initialize(ClientContext &, BaseUnionData &union_data) {
 		Initialize(std::move(union_data.reader));
 	}
+	bool SupportStatementCache() const override {
+		return false;
+	}
 
 	unique_ptr<FunctionData> Copy() const override;
 };

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

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "duckdb/original/std/memory.hpp"
+#include "duckdb/original/std/locale.hpp"
+#include "duckdb/original/std/sstream.hpp"
+#include "duckdb/common/unique_ptr.hpp"
+#include "duckdb/common/shared_ptr.hpp"
+
+#ifndef DUCKDB_CLANG_TIDY
+namespace std {
+template <class C>
+bool isspace(C c) {
+	static_assert(sizeof(C) == 0, "Use StringUtil::CharacterIsSpace instead of isspace!");
+	return false;
+}
+#ifndef DUCKDB_ENABLE_DEPRECATED_API
+template <class T, class... ARGS>
+static std::unique_ptr<T> make_unique(ARGS &&...__args) { // NOLINT: mimic std style
+	static_assert(sizeof(T) == 0, "Use make_uniq instead of make_unique!");
+	return nullptr;
+}
+
+template <class T, class... ARGS>
+static std::shared_ptr<T> make_shared(ARGS &&...__args) { // NOLINT: mimic std style
+	static_assert(sizeof(T) == 0, "Use make_shared_ptr instead of make_shared!");
+	return nullptr;
+}
+#endif // DUCKDB_ENABLE_DEPRECATED_API
+
+template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
+class basic_stringstream_mock;
+
+typedef basic_stringstream_mock<char> stringstream;
+
+} // namespace std
+
+using std::isspace;
+using std::make_shared;
+using std::make_unique;
+#endif

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

@@ -8,10 +8,33 @@
 
 #pragma once
 
-#include <sstream>
+#include "duckdb/original/std/sstream.hpp"
 #include <string>
+#include <locale>
 
 namespace duckdb {
 using std::string;
-using std::stringstream;
+} // namespace duckdb
+
+namespace duckdb {
+
+template <class charT, class traits = std::char_traits<charT>, class Allocator = std::allocator<charT>>
+class basic_stringstream : public duckdb_base_std::basic_stringstream<charT, traits, Allocator> {
+public:
+	using original = duckdb_base_std::basic_stringstream<charT, traits, Allocator>;
+
+	explicit basic_stringstream(std::ios_base::openmode which = std::ios_base::out | std::ios_base::in)
+	    : original(which) {
+		this->imbue(std::locale::classic());
+	}
+	explicit basic_stringstream(const std::basic_string<charT, traits, Allocator> &s,
+	                            std::ios_base::openmode which = std::ios_base::out | std::ios_base::in)
+	    : original(s, which) {
+		this->imbue(std::locale::classic());
+	}
+	basic_stringstream(const basic_stringstream &) = delete;
+	basic_stringstream(basic_stringstream &&rhs) noexcept;
+};
+
+typedef basic_stringstream<char> stringstream;
 } // namespace duckdb

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

@@ -129,46 +129,42 @@ public:
 	static int Sign(hugeint_t n);
 	static hugeint_t Abs(hugeint_t n);
 	// comparison operators
-	// note that everywhere here we intentionally use bitwise ops
-	// this is because they seem to be consistently much faster (benchmarked on a Macbook Pro)
 	static bool Equals(hugeint_t lhs, hugeint_t rhs) {
-		int lower_equals = lhs.lower == rhs.lower;
-		int upper_equals = lhs.upper == rhs.upper;
-		return lower_equals & upper_equals;
+		bool lower_equals = lhs.lower == rhs.lower;
+		bool upper_equals = lhs.upper == rhs.upper;
+		return lower_equals && upper_equals;
 	}
 
 	static bool NotEquals(hugeint_t lhs, hugeint_t rhs) {
-		int lower_not_equals = lhs.lower != rhs.lower;
-		int upper_not_equals = lhs.upper != rhs.upper;
-		return lower_not_equals | upper_not_equals;
+		return !Equals(lhs, rhs);
 	}
 
 	static bool GreaterThan(hugeint_t lhs, hugeint_t rhs) {
-		int upper_bigger = lhs.upper > rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_bigger = lhs.lower > rhs.lower;
-		return upper_bigger | (upper_equal & lower_bigger);
+		bool upper_bigger = lhs.upper > rhs.upper;
+		bool upper_equal = lhs.upper == rhs.upper;
+		bool lower_bigger = lhs.lower > rhs.lower;
+		return upper_bigger || (upper_equal && lower_bigger);
 	}
 
 	static bool GreaterThanEquals(hugeint_t lhs, hugeint_t rhs) {
-		int upper_bigger = lhs.upper > rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_bigger_equals = lhs.lower >= rhs.lower;
-		return upper_bigger | (upper_equal & lower_bigger_equals);
+		bool upper_bigger = lhs.upper > rhs.upper;
+		bool upper_equal = lhs.upper == rhs.upper;
+		bool lower_bigger_equals = lhs.lower >= rhs.lower;
+		return upper_bigger || (upper_equal && lower_bigger_equals);
 	}
 
 	static bool LessThan(hugeint_t lhs, hugeint_t rhs) {
-		int upper_smaller = lhs.upper < rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_smaller = lhs.lower < rhs.lower;
-		return upper_smaller | (upper_equal & lower_smaller);
+		bool upper_smaller = lhs.upper < rhs.upper;
+		bool upper_equal = lhs.upper == rhs.upper;
+		bool lower_smaller = lhs.lower < rhs.lower;
+		return upper_smaller || (upper_equal && lower_smaller);
 	}
 
 	static bool LessThanEquals(hugeint_t lhs, hugeint_t rhs) {
-		int upper_smaller = lhs.upper < rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_smaller_equals = lhs.lower <= rhs.lower;
-		return upper_smaller | (upper_equal & lower_smaller_equals);
+		bool upper_smaller = lhs.upper < rhs.upper;
+		bool upper_equal = lhs.upper == rhs.upper;
+		bool lower_smaller_equals = lhs.lower <= rhs.lower;
+		return upper_smaller || (upper_equal && lower_smaller_equals);
 	}
 
 	static constexpr uint8_t CACHED_POWERS_OF_TEN = 39;

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

@@ -118,46 +118,42 @@ public:
 	static hugeint_t Abs(hugeint_t n);
 
 	// comparison operators
-	// note that everywhere here we intentionally use bitwise ops
-	// this is because they seem to be consistently much faster (benchmarked on a Macbook Pro)
 	static bool Equals(uhugeint_t lhs, uhugeint_t rhs) {
-		int lower_equals = lhs.lower == rhs.lower;
-		int upper_equals = lhs.upper == rhs.upper;
-		return lower_equals & upper_equals;
+		bool lower_equals = lhs.lower == rhs.lower;
+		bool upper_equals = lhs.upper == rhs.upper;
+		return lower_equals && upper_equals;
 	}
 
 	static bool NotEquals(uhugeint_t lhs, uhugeint_t rhs) {
-		int lower_not_equals = lhs.lower != rhs.lower;
-		int upper_not_equals = lhs.upper != rhs.upper;
-		return lower_not_equals | upper_not_equals;
+		return !Equals(lhs, rhs);
 	}
 
 	static bool GreaterThan(uhugeint_t lhs, uhugeint_t rhs) {
-		int upper_bigger = lhs.upper > rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_bigger = lhs.lower > rhs.lower;
-		return upper_bigger | (upper_equal & lower_bigger);
+		bool upper_bigger = lhs.upper > rhs.upper;
+		bool upper_equal = lhs.upper == rhs.upper;
+		bool lower_bigger = lhs.lower > rhs.lower;
+		return upper_bigger || (upper_equal && lower_bigger);
 	}
 
 	static bool GreaterThanEquals(uhugeint_t lhs, uhugeint_t rhs) {
-		int upper_bigger = lhs.upper > rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_bigger_equals = lhs.lower >= rhs.lower;
-		return upper_bigger | (upper_equal & lower_bigger_equals);
+		bool upper_bigger = lhs.upper > rhs.upper;
+		bool upper_equal = lhs.upper == rhs.upper;
+		bool lower_bigger_equals = lhs.lower >= rhs.lower;
+		return upper_bigger || (upper_equal && lower_bigger_equals);
 	}
 
 	static bool LessThan(uhugeint_t lhs, uhugeint_t rhs) {
-		int upper_smaller = lhs.upper < rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_smaller = lhs.lower < rhs.lower;
-		return upper_smaller | (upper_equal & lower_smaller);
+		bool upper_smaller = lhs.upper < rhs.upper;
+		bool upper_equal = lhs.upper == rhs.upper;
+		bool lower_smaller = lhs.lower < rhs.lower;
+		return upper_smaller || (upper_equal && lower_smaller);
 	}
 
 	static bool LessThanEquals(uhugeint_t lhs, uhugeint_t rhs) {
-		int upper_smaller = lhs.upper < rhs.upper;
-		int upper_equal = lhs.upper == rhs.upper;
-		int lower_smaller_equals = lhs.lower <= rhs.lower;
-		return upper_smaller | (upper_equal & lower_smaller_equals);
+		bool upper_smaller = lhs.upper < rhs.upper;
+		bool upper_equal = lhs.upper == rhs.upper;
+		bool lower_smaller_equals = lhs.lower <= rhs.lower;
+		return upper_smaller || (upper_equal && lower_smaller_equals);
 	}
 
 	static constexpr uint8_t CACHED_POWERS_OF_TEN = 39;

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

@@ -349,6 +349,9 @@ struct LogicalType {
 
 	DUCKDB_API void Verify() const;
 
+	DUCKDB_API bool IsSigned() const;
+	DUCKDB_API bool IsUnsigned() const;
+
 	DUCKDB_API bool IsValid() const;
 	DUCKDB_API bool IsComplete() const;
 

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

@@ -3,16 +3,16 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/likely.hpp"
 #include "duckdb/common/memory_safety.hpp"
+#include "duckdb/original/std/memory.hpp"
 
-#include <memory>
 #include <type_traits>
 
 namespace duckdb {
 
 template <class DATA_TYPE, class DELETER = std::default_delete<DATA_TYPE>, bool SAFE = true>
-class unique_ptr : public std::unique_ptr<DATA_TYPE, DELETER> { // NOLINT: naming
+class unique_ptr : public duckdb_base_std::unique_ptr<DATA_TYPE, DELETER> { // NOLINT: naming
 public:
-	using original = std::unique_ptr<DATA_TYPE, DELETER>;
+	using original = duckdb_base_std::unique_ptr<DATA_TYPE, DELETER>;
 	using original::original; // NOLINT
 	using pointer = typename original::pointer;
 
@@ -54,11 +54,37 @@ public:
 	}
 };
 
-// FIXME: DELETER is defined, but we use std::default_delete???
+template <class DATA_TYPE, class DELETER>
+class unique_ptr<DATA_TYPE[], DELETER, true> : public duckdb_base_std::unique_ptr<DATA_TYPE[], DELETER> {
+public:
+	using original = duckdb_base_std::unique_ptr<DATA_TYPE[], DELETER>;
+	using original::original;
+
+private:
+	static inline void AssertNotNull(const bool null) {
+#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
+		return;
+#else
+		if (DUCKDB_UNLIKELY(null)) {
+			throw duckdb::InternalException("Attempted to dereference unique_ptr that is NULL!");
+		}
+#endif
+	}
+
+public:
+	typename std::add_lvalue_reference<DATA_TYPE>::type operator[](size_t __i) const { // NOLINT: hiding on purpose
+		const auto ptr = original::get();
+		if (MemorySafety<true>::ENABLED) {
+			AssertNotNull(!ptr);
+		}
+		return ptr[__i];
+	}
+};
+
 template <class DATA_TYPE, class DELETER, bool SAFE>
-class unique_ptr<DATA_TYPE[], DELETER, SAFE> : public std::unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>> {
+class unique_ptr<DATA_TYPE[], DELETER, SAFE> : public duckdb_base_std::unique_ptr<DATA_TYPE[], DELETER> {
 public:
-	using original = std::unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>>;
+	using original = duckdb_base_std::unique_ptr<DATA_TYPE[], DELETER>;
 	using original::original;
 
 private:
@@ -83,10 +109,10 @@ public:
 };
 
 template <typename T>
-using unique_array = unique_ptr<T[], std::default_delete<T>, true>;
+using unique_array = unique_ptr<T[], std::default_delete<T[]>, true>;
 
 template <typename T>
-using unsafe_unique_array = unique_ptr<T[], std::default_delete<T>, false>;
+using unsafe_unique_array = unique_ptr<T[], std::default_delete<T[]>, false>;
 
 template <typename T>
 using unsafe_unique_ptr = unique_ptr<T, std::default_delete<T>, false>;

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

@@ -26,6 +26,7 @@ public:
 
 protected:
 	vector<ColumnBinding> bindings;
+	vector<LogicalType> types;
 	bool verify_only;
 
 	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;

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

@@ -168,8 +168,8 @@ public:
 		TupleDataChunkState chunk_state;
 	};
 
-	JoinHashTable(ClientContext &context, const vector<JoinCondition> &conditions, vector<LogicalType> build_types,
-	              JoinType type, const vector<idx_t> &output_columns);
+	JoinHashTable(ClientContext &context, const PhysicalOperator &op, const vector<JoinCondition> &conditions,
+	              vector<LogicalType> build_types, JoinType type, const vector<idx_t> &output_columns);
 	~JoinHashTable();
 
 	//! Add the given data to the HT
@@ -214,6 +214,7 @@ public:
 	}
 
 	ClientContext &context;
+	const PhysicalOperator &op;
 	//! BufferManager
 	BufferManager &buffer_manager;
 	//! The join conditions

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/column_count_scanner.hpp

@@ -27,6 +27,8 @@ struct ColumnCount {
 	bool is_comment = false;
 	//! If this row is potentially a mid-line comment
 	bool is_mid_comment = false;
+	//! Number of empty lines before this value
+	idx_t empty_lines = 0;
 };
 
 class ColumnCountResult : public ScannerResult {
@@ -48,6 +50,7 @@ public:
 	map<idx_t, idx_t> rows_per_column_count;
 	CSVErrorHandler &error_handler;
 	map<idx_t, shared_ptr<CSVBufferHandle>> buffer_handles;
+	idx_t empty_lines = 0;
 	//! Adds a Value to the result
 	static inline void AddValue(ColumnCountResult &result, idx_t buffer_pos);
 	//! Adds a Row to the result

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/encode/csv_encoder.hpp

@@ -40,7 +40,7 @@ struct CSVEncoderBuffer {
 
 private:
 	//! The encoded buffer, we only have one per file, so we cache it and make sure to pass over unused bytes.
-	std::unique_ptr<char[]> encoded_buffer;
+	duckdb::unique_ptr<char[]> encoded_buffer;
 	//! The encoded buffer size is defined as buffer_size/GetRatio()
 	idx_t encoded_buffer_size;
 };

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp

@@ -30,6 +30,18 @@ struct QuoteEscapeCombination {
 	char escape;
 };
 
+//! Current stats of candidate analysis
+struct CandidateStats {
+	//! Number of rows read
+	idx_t rows_read = 0;
+	//! Best Number of consistent rows (i.e., presenting all columns)
+	idx_t best_consistent_rows = 0;
+	//! If padding was necessary (i.e., rows are missing some columns, how many)
+	idx_t prev_padding_count = 0;
+	//! Min number of ignored rows
+	idx_t min_ignored_rows = 0;
+};
+
 //! All the options that will be used to sniff the dialect of the CSV file
 struct DialectCandidates {
 	//! The constructor populates all of our the options that will be used in our sniffer search space
@@ -131,9 +143,9 @@ private:
 	void GenerateStateMachineSearchSpace(vector<unique_ptr<ColumnCountScanner>> &column_count_scanners,
 	                                     const DialectCandidates &dialect_candidates);
 
-	//! 2. Analyzes if dialect candidate is a good candidate to be considered, if so, it adds it to the candidates
-	void AnalyzeDialectCandidate(unique_ptr<ColumnCountScanner>, idx_t &rows_read, idx_t &best_consistent_rows,
-	                             idx_t &prev_padding_count, idx_t &min_ignored_rows);
+	//! 2. Analyzes if a dialect candidate is a good candidate to be considered, if so, it adds it to the candidates
+	void AnalyzeDialectCandidate(unique_ptr<ColumnCountScanner>, CandidateStats &stats,
+	                             vector<unique_ptr<ColumnCountScanner>> &successful_candidates);
 	//! 3. Refine Candidates over remaining chunks
 	void RefineCandidates();
 

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

@@ -197,9 +197,9 @@ struct VectorCastHelpers {
 
 		if (STRUCT_KEY) {
 			needs_quotes = true;
-		} else if (isspace(string_data[0])) {
+		} else if (StringUtil::CharacterIsSpace(string_data[0])) {
 			needs_quotes = true;
-		} else if (base_length >= 2 && isspace(string_data[base_length - 1])) {
+		} else if (base_length >= 2 && StringUtil::CharacterIsSpace(string_data[base_length - 1])) {
 			needs_quotes = true;
 		} else if (StringUtil::CIEquals(string_data, base_length, "null", 4)) {
 			needs_quotes = true;

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

@@ -20,6 +20,7 @@ struct CopyFunctionFileStatistics;
 class Binder;
 class ColumnDataCollection;
 class ExecutionContext;
+class PhysicalOperatorLogger;
 
 struct LocalFunctionData {
 	virtual ~LocalFunctionData() = default;
@@ -123,6 +124,8 @@ typedef void (*copy_to_get_written_statistics_t)(ClientContext &context, Functio
 
 typedef vector<unique_ptr<Expression>> (*copy_to_select_t)(CopyToSelectInput &input);
 
+typedef void (*copy_to_initialize_operator_t)(GlobalFunctionData &gstate, const PhysicalOperator &op);
+
 enum class CopyFunctionReturnType : uint8_t {
 	CHANGED_ROWS = 0,
 	CHANGED_ROWS_AND_FILE_LIST = 1,
@@ -145,9 +148,9 @@ public:
 	    : Function(name), plan(nullptr), copy_to_select(nullptr), copy_to_bind(nullptr),
 	      copy_to_initialize_local(nullptr), copy_to_initialize_global(nullptr),
 	      copy_to_get_written_statistics(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) {
+	      copy_to_finalize(nullptr), execution_mode(nullptr), initialize_operator(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
@@ -162,6 +165,7 @@ public:
 	copy_to_combine_t copy_to_combine;
 	copy_to_finalize_t copy_to_finalize;
 	copy_to_execution_mode_t execution_mode;
+	copy_to_initialize_operator_t initialize_operator;
 
 	copy_prepare_batch_t prepare_batch;
 	copy_flush_batch_t flush_batch;

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

@@ -61,6 +61,7 @@ struct FunctionData {
 	DUCKDB_API virtual unique_ptr<FunctionData> Copy() const = 0;
 	DUCKDB_API virtual bool Equals(const FunctionData &other) const = 0;
 	DUCKDB_API static bool Equals(const FunctionData *left, const FunctionData *right);
+	DUCKDB_API virtual bool SupportStatementCache() const;
 
 	template <class TARGET>
 	TARGET &Cast() {

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

@@ -73,9 +73,10 @@ public:
 	                                           const vector<unique_ptr<Expression>> &groups);
 	DUCKDB_API static void BindSortedAggregate(ClientContext &context, BoundWindowExpression &expr);
 
-private:
 	//! Cast a set of expressions to the arguments of this function
 	void CastToFunctionArguments(SimpleFunction &function, vector<unique_ptr<Expression>> &children);
+
+private:
 	optional_idx BindVarArgsFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments);
 	optional_idx BindFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments);