duckdb 0.7.2-dev3666.0 → 0.7.2-dev3763.0

package/src/duckdb/src/function/table/table_scan.cpp

@@ -207,7 +207,7 @@ struct IndexScanGlobalState : public GlobalTableFunctionState {
 	Vector row_ids;
 	ColumnFetchState fetch_state;
 	TableScanState local_storage_state;
-	vector<column_t> column_ids;
+	vector<storage_t> column_ids;
 	bool finished;
 };
 
@@ -219,8 +219,12 @@ static unique_ptr<GlobalTableFunctionState> IndexScanInitGlobal(ClientContext &c
 	}
 	auto result = make_uniq<IndexScanGlobalState>(row_id_data);
 	auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog);
-	result->column_ids = input.column_ids;
-	result->local_storage_state.Initialize(input.column_ids, input.filters.get());
+
+	result->column_ids.reserve(input.column_ids.size());
+	for (auto &id : input.column_ids) {
+		result->column_ids.push_back(GetStorageIndex(bind_data.table, id));
+	}
+	result->local_storage_state.Initialize(result->column_ids, input.filters.get());
 	local_storage.InitializeScan(bind_data.table.GetStorage(), result->local_storage_state.local_state, input.filters);
 
 	result->finished = false;

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,16 +1,14 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev3666"
+#define DUCKDB_VERSION "0.7.2-dev3763"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "eae707d54c"
+#define DUCKDB_SOURCE_ID "d3562b54ee"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"
 
 #include <cstdint>
 
-#define DUCKDB_STRINGIFY(x) #x
-
 namespace duckdb {
 
 struct PragmaVersionData : public GlobalTableFunctionState {
@@ -93,8 +91,8 @@ string DuckDB::Platform() {
 	postfix = "_mingw";
 #endif
 // this is used for the windows R builds which use a separate build environment
-#ifdef DUCKDB_OVERRIDE_PLATFORM_POSTFIX
-	postfix = DUCKDB_STRINGIFY(DUCKDB_OVERRIDE_PLATFORM_POSTFIX);
+#ifdef DUCKDB_PLATFORM_RTOOLS
+	postfix = "_rtools";
 #endif
 	return os + "_" + arch + postfix;
 }

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

@@ -18,8 +18,8 @@ struct StreamData {
 	// various buffers & pointers
 	bool write = false;
 	bool refresh = false;
-	unsafe_array_ptr<data_t> in_buff;
-	unsafe_array_ptr<data_t> out_buff;
+	unsafe_unique_array<data_t> in_buff;
+	unsafe_unique_array<data_t> out_buff;
 	data_ptr_t out_buff_start = nullptr;
 	data_ptr_t out_buff_end = nullptr;
 	data_ptr_t in_buff_start = nullptr;

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

@@ -15,6 +15,28 @@
 
 namespace duckdb {
 
+// Helper class to support custom overloading
+// Escaping " and quoting the value with "
+class SQLIdentifier {
+public:
+	SQLIdentifier(const string &raw_string) : raw_string(raw_string) {
+	}
+
+public:
+	string raw_string;
+};
+
+// Helper class to support custom overloading
+// Escaping ' and quoting the value with '
+class SQLString {
+public:
+	SQLString(const string &raw_string) : raw_string(raw_string) {
+	}
+
+public:
+	string raw_string;
+};
+
 enum class PhysicalType : uint8_t;
 struct LogicalType;
 
@@ -47,6 +69,10 @@ public:
 template <>
 DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(PhysicalType value);
 template <>
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(SQLString value);
+template <>
+DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(SQLIdentifier value);
+template <>
 DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(LogicalType value);
 template <>
 DUCKDB_API ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(float value);

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

@@ -178,6 +178,9 @@ public:
 	DUCKDB_API static string PathSeparator();
 	//! Checks if path is starts with separator (i.e., '/' on UNIX '\\' on Windows)
 	DUCKDB_API static bool IsPathAbsolute(const string &path);
+	//! Normalize an absolute path - the goal of normalizing is converting "\test.db" and "C:/test.db" into "C:\test.db"
+	//! so that the database system cache can correctly
+	DUCKDB_API static string NormalizeAbsolutePath(const string &path);
 	//! Join two paths together
 	DUCKDB_API static string JoinPath(const string &a, const string &path);
 	//! Convert separators in a path to the local separators (e.g. convert "/" into \\ on windows)
@@ -187,6 +190,9 @@ public:
 	//! Extract the name of a file (e.g if the input is lib/example.dll the name is 'example.dll')
 	DUCKDB_API static string ExtractName(const string &path);
 
+	//! Returns the value of an environment variable - or the empty string if it is not set
+	DUCKDB_API static string GetEnvVariable(const string &name);
+
 	//! Whether there is a glob in the string
 	DUCKDB_API static bool HasGlob(const string &str);
 	//! Runs a glob on the file system, returning a list of matching files

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

@@ -40,7 +40,7 @@ namespace duckdb {
 template<class _Tp, bool SAFE = true>
 struct __unique_if
 {
-    typedef unique_ptr<_Tp, SAFE> __unique_single;
+    typedef unique_ptr<_Tp, std::default_delete<_Tp>, SAFE> __unique_single;
 };
 
 template<class _Tp>
@@ -60,7 +60,7 @@ inline
 typename __unique_if<_Tp, true>::__unique_single
 make_uniq(_Args&&... __args)
 {
-    return unique_ptr<_Tp, true>(new _Tp(std::forward<_Args>(__args)...));
+    return unique_ptr<_Tp, std::default_delete<_Tp>, true>(new _Tp(std::forward<_Args>(__args)...));
 }
 
 template<class _Tp, class... _Args>
@@ -68,21 +68,21 @@ inline
 typename __unique_if<_Tp, false>::__unique_single
 make_unsafe_uniq(_Args&&... __args)
 {
-    return unique_ptr<_Tp, false>(new _Tp(std::forward<_Args>(__args)...));
+    return unique_ptr<_Tp, std::default_delete<_Tp>, false>(new _Tp(std::forward<_Args>(__args)...));
 }
 
 template<class _Tp>
-inline unique_ptr<_Tp[], true>
-make_array(size_t __n)
+inline unique_ptr<_Tp[], std::default_delete<_Tp>, true>
+make_uniq_array(size_t __n)
 {
-    return unique_ptr<_Tp[], true>(new _Tp[__n]());
+    return unique_ptr<_Tp[], std::default_delete<_Tp>, true>(new _Tp[__n]());
 }
 
 template<class _Tp>
-inline unique_ptr<_Tp[], false>
-make_unsafe_array(size_t __n)
+inline unique_ptr<_Tp[], std::default_delete<_Tp>, false>
+make_unsafe_uniq_array(size_t __n)
 {
-    return unique_ptr<_Tp[], false>(new _Tp[__n]());
+    return unique_ptr<_Tp[], std::default_delete<_Tp>, false>(new _Tp[__n]());
 }
 
 template<class _Tp, class... _Args>

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

@@ -49,10 +49,10 @@ public:
 	}
 
 	//! helper function to get the HTTP
-	static optional_ptr<HTTPState> TryGetState(FileOpener *opener) {
+	static shared_ptr<HTTPState> TryGetState(FileOpener *opener) {
 		auto client_context = FileOpener::TryGetClientContext(opener);
 		if (client_context) {
-			return client_context->client_data->http_state.get();
+			return client_context->client_data->http_state;
 		}
 		return nullptr;
 	}

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

@@ -18,7 +18,7 @@ public:
 	                   FileLockType lock_type = FileLockType::READ_LOCK, optional_ptr<FileOpener> opener = nullptr);
 
 	FileSystem &fs;
-	unsafe_array_ptr<data_t> data;
+	unsafe_unique_array<data_t> data;
 	idx_t offset;
 	idx_t read_data;
 	unique_ptr<FileHandle> handle;

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

@@ -25,7 +25,7 @@ public:
 
 	FileSystem &fs;
 	string path;
-	unsafe_array_ptr<data_t> data;
+	unsafe_unique_array<data_t> data;
 	idx_t offset;
 	idx_t total_written;
 	unique_ptr<FileHandle> handle;

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

@@ -16,7 +16,7 @@ namespace duckdb {
 #define SERIALIZER_DEFAULT_SIZE 1024
 
 struct BinaryData {
-	unsafe_array_ptr<data_t> data;
+	unsafe_unique_array<data_t> data;
 	idx_t size;
 };
 
@@ -26,7 +26,7 @@ public:
 	//! writing past the initial threshold
 	DUCKDB_API explicit BufferedSerializer(idx_t maximum_size = SERIALIZER_DEFAULT_SIZE);
 	//! Serializes to a provided (owned) data pointer
-	BufferedSerializer(unsafe_array_ptr<data_t> data, idx_t size);
+	BufferedSerializer(unsafe_unique_array<data_t> data, idx_t size);
 	BufferedSerializer(data_ptr_t data, idx_t size);
 
 	idx_t maximum_size;

package/src/duckdb/src/include/duckdb/common/sort/duckdb_pdqsort.hpp

@@ -39,10 +39,10 @@ using duckdb::idx_t;
 using duckdb::data_t;
 using duckdb::data_ptr_t;
 using duckdb::unique_ptr;
-using duckdb::array_ptr;
-using duckdb::unsafe_array_ptr;
-using duckdb::make_array;
-using duckdb::make_unsafe_array;
+using duckdb::unique_array;
+using duckdb::unsafe_unique_array;
+using duckdb::make_uniq_array;
+using duckdb::make_unsafe_uniq_array;
 using duckdb::FastMemcpy;
 using duckdb::FastMemcmp;
 
@@ -78,9 +78,9 @@ inline int log2(T n) {
 struct PDQConstants {
 	PDQConstants(idx_t entry_size, idx_t comp_offset, idx_t comp_size, data_ptr_t end)
 	    : entry_size(entry_size), comp_offset(comp_offset), comp_size(comp_size),
-	      tmp_buf_ptr(make_unsafe_array<data_t>(entry_size)), tmp_buf(tmp_buf_ptr.get()),
-	      iter_swap_buf_ptr(make_unsafe_array<data_t>(entry_size)), iter_swap_buf(iter_swap_buf_ptr.get()),
-	      swap_offsets_buf_ptr(make_unsafe_array<data_t>(entry_size)),
+	      tmp_buf_ptr(make_unsafe_uniq_array<data_t>(entry_size)), tmp_buf(tmp_buf_ptr.get()),
+	      iter_swap_buf_ptr(make_unsafe_uniq_array<data_t>(entry_size)), iter_swap_buf(iter_swap_buf_ptr.get()),
+	      swap_offsets_buf_ptr(make_unsafe_uniq_array<data_t>(entry_size)),
 	      swap_offsets_buf(swap_offsets_buf_ptr.get()), end(end) {
 	}
 
@@ -88,13 +88,13 @@ struct PDQConstants {
 	const idx_t comp_offset;
 	const idx_t comp_size;
 
-	unsafe_array_ptr<data_t> tmp_buf_ptr;
+	unsafe_unique_array<data_t> tmp_buf_ptr;
 	const data_ptr_t tmp_buf;
 
-	unsafe_array_ptr<data_t> iter_swap_buf_ptr;
+	unsafe_unique_array<data_t> iter_swap_buf_ptr;
 	const data_ptr_t iter_swap_buf;
 
-	unsafe_array_ptr<data_t> swap_offsets_buf_ptr;
+	unsafe_unique_array<data_t> swap_offsets_buf_ptr;
 	const data_ptr_t swap_offsets_buf;
 
 	const data_ptr_t end;

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

@@ -15,6 +15,7 @@
 #include <cstring>
 
 namespace duckdb {
+
 /**
  * String Utility Functions
  * Note that these are not the most efficient implementations (i.e., they copy
@@ -85,6 +86,23 @@ public:
 		return false;
 	}
 
+	template <class TO>
+	static vector<TO> ConvertStrings(const vector<string> &strings) {
+		vector<TO> result;
+		for (auto &string : strings) {
+			result.emplace_back(string);
+		}
+		return result;
+	}
+
+	static vector<SQLIdentifier> ConvertToSQLIdentifiers(const vector<string> &strings) {
+		return ConvertStrings<SQLIdentifier>(strings);
+	}
+
+	static vector<SQLString> ConvertToSQLStrings(const vector<string> &strings) {
+		return ConvertStrings<SQLString>(strings);
+	}
+
 	//! Returns true if the needle string exists in the haystack
 	DUCKDB_API static bool Contains(const string &haystack, const string &needle);
 
@@ -145,6 +163,8 @@ public:
 	//! Convert a string to lowercase
 	DUCKDB_API static string Lower(const string &str);
 
+	DUCKDB_API static bool IsLower(const string &str);
+
 	//! Case insensitive hash
 	DUCKDB_API static uint64_t CIHash(const string &str);
 

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

@@ -125,7 +125,7 @@ public:
 	DUCKDB_API void Flatten();
 
 	// FIXME: this is DUCKDB_API, might need conversion back to regular unique ptr?
-	DUCKDB_API unsafe_array_ptr<UnifiedVectorFormat> ToUnifiedFormat();
+	DUCKDB_API unsafe_unique_array<UnifiedVectorFormat> ToUnifiedFormat();
 
 	DUCKDB_API void Slice(const SelectionVector &sel_vector, idx_t count);
 

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

@@ -18,7 +18,7 @@ class VectorBuffer;
 struct SelectionData {
 	DUCKDB_API explicit SelectionData(idx_t count);
 
-	unsafe_array_ptr<sel_t> owned_data;
+	unsafe_unique_array<sel_t> owned_data;
 };
 
 struct SelectionVector {

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

@@ -24,7 +24,7 @@ struct TemplatedValidityData {
 public:
 	inline explicit TemplatedValidityData(idx_t count) {
 		auto entry_count = EntryCount(count);
-		owned_data = make_unsafe_array<V>(entry_count);
+		owned_data = make_unsafe_uniq_array<V>(entry_count);
 		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
 			owned_data[entry_idx] = MAX_ENTRY;
 		}
@@ -32,13 +32,13 @@ public:
 	inline TemplatedValidityData(const V *validity_mask, idx_t count) {
 		D_ASSERT(validity_mask);
 		auto entry_count = EntryCount(count);
-		owned_data = make_unsafe_array<V>(entry_count);
+		owned_data = make_unsafe_uniq_array<V>(entry_count);
 		for (idx_t entry_idx = 0; entry_idx < entry_count; entry_idx++) {
 			owned_data[entry_idx] = validity_mask[entry_idx];
 		}
 	}
 
-	unsafe_array_ptr<V> owned_data;
+	unsafe_unique_array<V> owned_data;
 
 public:
 	static inline idx_t EntryCount(idx_t count) {

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

@@ -71,10 +71,10 @@ public:
 	}
 	explicit VectorBuffer(idx_t data_size) : buffer_type(VectorBufferType::STANDARD_BUFFER) {
 		if (data_size > 0) {
-			data = make_unsafe_array<data_t>(data_size);
+			data = make_unsafe_uniq_array<data_t>(data_size);
 		}
 	}
-	explicit VectorBuffer(unsafe_array_ptr<data_t> data_p)
+	explicit VectorBuffer(unsafe_unique_array<data_t> data_p)
 	    : buffer_type(VectorBufferType::STANDARD_BUFFER), data(std::move(data_p)) {
 	}
 	virtual ~VectorBuffer() {
@@ -87,7 +87,7 @@ public:
 		return data.get();
 	}
 
-	void SetData(unsafe_array_ptr<data_t> new_data) {
+	void SetData(unsafe_unique_array<data_t> new_data) {
 		data = std::move(new_data);
 	}
 
@@ -120,7 +120,7 @@ public:
 protected:
 	VectorBufferType buffer_type;
 	unique_ptr<VectorAuxiliaryData> aux_data;
-	unsafe_array_ptr<data_t> data;
+	unsafe_unique_array<data_t> data;
 };
 
 //! The DictionaryBuffer holds a selection vector

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

@@ -9,10 +9,10 @@
 
 namespace duckdb {
 
-template <class _Tp, bool SAFE = true>
-class unique_ptr : public std::unique_ptr<_Tp, std::default_delete<_Tp>> {
+template <class _Tp, class _Dp = std::default_delete<_Tp>, bool SAFE = true>
+class unique_ptr : public std::unique_ptr<_Tp, _Dp> {
 public:
-	using original = std::unique_ptr<_Tp, std::default_delete<_Tp>>;
+	using original = std::unique_ptr<_Tp, _Dp>;
 	using original::original;
 
 private:
@@ -53,8 +53,8 @@ public:
 	}
 };
 
-template <class _Tp, bool SAFE>
-class unique_ptr<_Tp[], SAFE> : public std::unique_ptr<_Tp[], std::default_delete<_Tp[]>> {
+template <class _Tp, class _Dp, bool SAFE>
+class unique_ptr<_Tp[], _Dp, SAFE> : public std::unique_ptr<_Tp[], std::default_delete<_Tp[]>> {
 public:
 	using original = std::unique_ptr<_Tp[], std::default_delete<_Tp[]>>;
 	using original::original;
@@ -81,12 +81,12 @@ public:
 };
 
 template <typename T>
-using array_ptr = unique_ptr<T[], true>;
+using unique_array = unique_ptr<T[], std::default_delete<T>, true>;
 
 template <typename T>
-using unsafe_array_ptr = unique_ptr<T[], false>;
+using unsafe_unique_array = unique_ptr<T[], std::default_delete<T>, false>;
 
 template <typename T>
-using unsafe_unique_ptr = unique_ptr<T, false>;
+using unsafe_unique_ptr = unique_ptr<T, std::default_delete<T>, false>;
 
 } // namespace duckdb

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

@@ -73,7 +73,7 @@ struct AggregateHTAppendState {
 	SelectionVector empty_vector;
 	SelectionVector new_groups;
 	Vector addresses;
-	unsafe_array_ptr<UnifiedVectorFormat> group_data;
+	unsafe_unique_array<UnifiedVectorFormat> group_data;
 	DataChunk group_chunk;
 
 	TupleDataChunkState chunk_state;

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

@@ -65,12 +65,12 @@ public:
 	//! returned by the JoinHashTable::Scan function and can be used to resume a
 	//! probe.
 	struct ScanStructure {
-		unsafe_array_ptr<UnifiedVectorFormat> key_data;
+		unsafe_unique_array<UnifiedVectorFormat> key_data;
 		Vector pointers;
 		idx_t count;
 		SelectionVector sel_vector;
 		// whether or not the given tuple has found a match
-		unsafe_array_ptr<bool> found_match;
+		unsafe_unique_array<bool> found_match;
 		JoinHashTable &ht;
 		bool finished;
 
@@ -212,7 +212,7 @@ private:
 	//! Insert the given set of locations into the HT with the given set of hashes
 	void InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_locations[], bool parallel);
 
-	idx_t PrepareKeys(DataChunk &keys, unsafe_array_ptr<UnifiedVectorFormat> &key_data,
+	idx_t PrepareKeys(DataChunk &keys, unsafe_unique_array<UnifiedVectorFormat> &key_data,
 	                  const SelectionVector *&current_sel, SelectionVector &sel, bool build_side);
 
 	//! Lock for combining data_collection when merging HTs

package/src/duckdb/src/include/duckdb/execution/operator/join/outer_join_marker.hpp

@@ -67,7 +67,7 @@ public:
 
 private:
 	bool enabled;
-	unsafe_array_ptr<bool> found_match;
+	unsafe_unique_array<bool> found_match;
 	idx_t count;
 };
 

package/src/duckdb/src/include/duckdb/execution/operator/join/perfect_hash_join_executor.hpp

@@ -68,7 +68,7 @@ private:
 	//! Build and probe statistics
 	PerfectHashJoinStats perfect_join_statistics;
 	//! Stores the occurences of each value in the build side
-	unsafe_array_ptr<bool> bitmap_build_idx;
+	unsafe_unique_array<bool> bitmap_build_idx;
 	//! Stores the number of unique keys in the build side
 	idx_t unique_keys = 0;
 };

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_range_join.hpp

@@ -83,7 +83,7 @@ public:
 		//! The total number of rows in the RHS
 		atomic<idx_t> count;
 		//! A bool indicating for each tuple in the RHS if they found a match (only used in FULL OUTER JOIN)
-		unsafe_array_ptr<bool> found_match;
+		unsafe_unique_array<bool> found_match;
 		//! Memory usage per thread
 		idx_t memory_per_thread;
 	};

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

@@ -60,12 +60,12 @@ public:
 	virtual ~BufferedCSVReader() {
 	}
 
-	unsafe_array_ptr<char> buffer;
+	unsafe_unique_array<char> buffer;
 	idx_t buffer_size;
 	idx_t position;
 	idx_t start = 0;
 
-	vector<unsafe_array_ptr<char>> cached_buffers;
+	vector<unsafe_unique_array<char>> cached_buffers;
 
 	unique_ptr<CSVFileHandle> file_handle;
 

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

@@ -67,7 +67,7 @@ struct CSVBufferRead {
 		} else {
 			// 3) It starts in the current buffer and ends in the next buffer
 			D_ASSERT(next_buffer);
-			auto intersection = make_unsafe_array<char>(length);
+			auto intersection = make_unsafe_uniq_array<char>(length);
 			idx_t cur_pos = 0;
 			auto buffer_ptr = buffer->Ptr();
 			for (idx_t i = start_buffer; i < buffer->GetBufferSize(); i++) {
@@ -85,7 +85,7 @@ struct CSVBufferRead {
 
 	shared_ptr<CSVBuffer> buffer;
 	shared_ptr<CSVBuffer> next_buffer;
-	vector<unsafe_array_ptr<char>> intersections;
+	vector<unsafe_unique_array<char>> intersections;
 	optional_ptr<LineInfo> line_info;
 
 	idx_t buffer_start;

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

@@ -115,10 +115,9 @@ protected:
 	void CombineExistingAndInsertTuples(DataChunk &result, DataChunk &scan_chunk, DataChunk &input_chunk,
 	                                    ClientContext &client) const;
 	//! Returns the amount of updated tuples
+	void CreateUpdateChunk(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table, Vector &row_ids,
+	                       DataChunk &result) const;
 	idx_t OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context, InsertLocalState &lstate) const;
-	idx_t PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table,
-	                              Vector &row_ids) const;
-	void RegisterUpdatedRows(InsertLocalState &lstate, const Vector &row_ids, idx_t count) const;
 };
 
 } // namespace duckdb

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

@@ -46,9 +46,9 @@ protected:
 	// The actual pointer to the data
 	data_ptr_t data;
 	//! The owned data of the HT
-	unsafe_array_ptr<data_t> owned_data;
+	unsafe_unique_array<data_t> owned_data;
 	//! Information on whether or not a specific group has any entries
-	unsafe_array_ptr<bool> group_is_set;
+	unsafe_unique_array<bool> group_is_set;
 
 	//! The minimum values for each of the group columns
 	vector<Value> group_minima;

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

@@ -113,7 +113,7 @@ private:
 	Vector statev;
 
 	//! The actual window segment tree: an array of aggregate states that represent all the intermediate nodes
-	unsafe_array_ptr<data_t> levels_flat_native;
+	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;
 

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

@@ -55,7 +55,7 @@ struct WriteCSVData : public BaseCSVData {
 	//! The size of the CSV file (in bytes) that we buffer before we flush it to disk
 	idx_t flush_size = 4096 * 8;
 	//! For each byte whether or not the CSV file requires quotes when containing the byte
-	unsafe_array_ptr<bool> requires_quotes;
+	unsafe_unique_array<bool> requires_quotes;
 };
 
 struct ColumnInfo {

package/src/duckdb/src/include/duckdb/main/client_data.hpp

@@ -54,7 +54,7 @@ struct ClientData {
 	unique_ptr<FileOpener> file_opener;
 
 	//! HTTP State in this query
-	unique_ptr<HTTPState> http_state;
+	shared_ptr<HTTPState> http_state;
 
 	//! The clients' file system wrapper
 	unique_ptr<FileSystem> client_file_system;

package/src/duckdb/src/include/duckdb/optimizer/join_order/join_relation.hpp

@@ -27,12 +27,12 @@ struct SingleJoinRelation {
 
 //! Set of relations, used in the join graph.
 struct JoinRelationSet {
-	JoinRelationSet(unsafe_array_ptr<idx_t> relations, idx_t count) : relations(std::move(relations)), count(count) {
+	JoinRelationSet(unsafe_unique_array<idx_t> relations, idx_t count) : relations(std::move(relations)), count(count) {
 	}
 
 	string ToString() const;
 
-	unsafe_array_ptr<idx_t> relations;
+	unsafe_unique_array<idx_t> relations;
 	idx_t count;
 
 	static bool IsSubset(JoinRelationSet &super, JoinRelationSet &sub);
@@ -55,7 +55,7 @@ public:
 	//! Create or get a JoinRelationSet from a set of relation bindings
 	JoinRelationSet &GetJoinRelation(unordered_set<idx_t> &bindings);
 	//! Create or get a JoinRelationSet from a (sorted, duplicate-free!) list of relations
-	JoinRelationSet &GetJoinRelation(unsafe_array_ptr<idx_t> relations, idx_t count);
+	JoinRelationSet &GetJoinRelation(unsafe_unique_array<idx_t> relations, idx_t count);
 	//! Union two sets of relations together and create a new relation set
 	JoinRelationSet &Union(JoinRelationSet &left, JoinRelationSet &right);
 	// //! Create the set difference of left \ right (i.e. all elements in left that are not in right)

package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp

@@ -92,7 +92,7 @@ public:
 		result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
 			return child->alias.empty() || !add_alias
 			           ? child->ToString()
-			           : KeywordHelper::WriteOptionallyQuoted(child->alias) + " := " + child->ToString();
+			           : StringUtil::Format("%s := %s", SQLIdentifier(child->alias), child->ToString());
 		});
 		// ordered aggregate
 		if (order_bys && !order_bys->orders.empty()) {

package/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp

@@ -96,8 +96,8 @@ public:
 			auto child_string = entry.children[1]->ToString();
 			D_ASSERT(child_string.size() >= 3);
 			D_ASSERT(child_string[0] == '\'' && child_string[child_string.size() - 1] == '\'');
-			return "(" + entry.children[0]->ToString() + ")." +
-			       KeywordHelper::WriteOptionallyQuoted(child_string.substr(1, child_string.size() - 2));
+			return StringUtil::Format("(%s).%s", entry.children[0]->ToString(),
+			                          SQLIdentifier(child_string.substr(1, child_string.size() - 2)));
 		}
 		case ExpressionType::ARRAY_CONSTRUCTOR: {
 			string result = "(ARRAY[";

package/src/duckdb/src/include/duckdb/parser/keyword_helper.hpp

@@ -17,9 +17,14 @@ public:
 	//! Returns true if the given text matches a keyword of the parser
 	static bool IsKeyword(const string &text);
 
+	static string EscapeQuotes(const string &text, char quote = '"');
+
 	//! Returns true if the given string needs to be quoted when written as an identifier
 	static bool RequiresQuotes(const string &text, bool allow_caps = true);
 
+	//! Writes a string that is quoted
+	static string WriteQuoted(const string &text, char quote = '\'');
+
 	//! Writes a string that is optionally quoted + escaped so it can be used as an identifier
 	static string WriteOptionallyQuoted(const string &text, char quote = '"', bool allow_caps = true);
 };