duckdb 0.7.2-dev3710.0 → 0.7.2-dev3763.0

package/src/duckdb/src/execution/operator/persistent/physical_insert.cpp

@@ -101,7 +101,9 @@ public:
 	unique_ptr<RowGroupCollection> local_collection;
 	optional_ptr<OptimisticDataWriter> writer;
 	// Rows that have been updated by a DO UPDATE conflict
-	unordered_set<row_t> updated_rows;
+	unordered_set<row_t> updated_global_rows;
+	// Rows in the transaction-local storage that have been updated by a DO UPDATE conflict
+	unordered_set<row_t> updated_local_rows;
 	idx_t update_count = 0;
 };
 
@@ -177,8 +179,11 @@ void CheckOnConflictCondition(ExecutionContext &context, DataChunk &conflicts, c
 	result.SetCardinality(conflicts.size());
 }
 
-void PhysicalInsert::CombineExistingAndInsertTuples(DataChunk &result, DataChunk &scan_chunk, DataChunk &input_chunk,
-                                                    ClientContext &client) const {
+static void CombineExistingAndInsertTuples(DataChunk &result, DataChunk &scan_chunk, DataChunk &input_chunk,
+                                           ClientContext &client, const PhysicalInsert &op) {
+	auto &types_to_fetch = op.types_to_fetch;
+	auto &insert_types = op.insert_types;
+
 	if (types_to_fetch.empty()) {
 		// We have not scanned the initial table, so we can just duplicate the initial chunk
 		result.Initialize(client, input_chunk.GetTypes());
@@ -218,14 +223,12 @@ void PhysicalInsert::CombineExistingAndInsertTuples(DataChunk &result, DataChunk
 	result.SetCardinality(input_chunk.size());
 }
 
-idx_t PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table,
-                                              Vector &row_ids) const {
-	if (action_type == OnConflictAction::NOTHING) {
-		return 0;
-	}
-
-	DataChunk update_chunk; // contains only the to-update columns
+static void CreateUpdateChunk(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table, Vector &row_ids,
+                              DataChunk &update_chunk, const PhysicalInsert &op) {
 
+	auto &do_update_condition = op.do_update_condition;
+	auto &set_types = op.set_types;
+	auto &set_expressions = op.set_expressions;
 	// Check the optional condition for the DO UPDATE clause, to filter which rows will be updated
 	if (do_update_condition) {
 		DataChunk do_update_filter_result;
@@ -256,19 +259,43 @@ idx_t PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChu
 	ExpressionExecutor executor(context.client, set_expressions);
 	executor.Execute(chunk, update_chunk);
 	update_chunk.SetCardinality(chunk);
+}
+
+template <bool GLOBAL>
+static idx_t PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table,
+                                     Vector &row_ids, const PhysicalInsert &op) {
+
+	if (op.action_type == OnConflictAction::NOTHING) {
+		return 0;
+	}
+	auto &set_columns = op.set_columns;
+
+	DataChunk update_chunk;
+	CreateUpdateChunk(context, chunk, table, row_ids, update_chunk, op);
 
 	auto &data_table = table.GetStorage();
 	// Perform the update, using the results of the SET expressions
-	data_table.Update(table, context.client, row_ids, set_columns, update_chunk);
+	if (GLOBAL) {
+		data_table.Update(table, context.client, row_ids, set_columns, update_chunk);
+	} else {
+		auto &local_storage = LocalStorage::Get(context.client, data_table.db);
+		// Perform the update, using the results of the SET expressions
+		local_storage.Update(data_table, row_ids, set_columns, update_chunk);
+	}
 	return update_chunk.size();
 }
 
 // TODO: should we use a hash table to keep track of this instead?
-void PhysicalInsert::RegisterUpdatedRows(InsertLocalState &lstate, const Vector &row_ids, idx_t count) const {
+template <bool GLOBAL>
+static void RegisterUpdatedRows(InsertLocalState &lstate, const Vector &row_ids, idx_t count) {
 	// Insert all rows, if any of the rows has already been updated before, we throw an error
 	auto data = FlatVector::GetData<row_t>(row_ids);
+
+	// The rowids in the transaction-local ART aren't final yet so we have to separately keep track of the two sets of
+	// rowids
+	unordered_set<row_t> &updated_rows = GLOBAL ? lstate.updated_global_rows : lstate.updated_local_rows;
 	for (idx_t i = 0; i < count; i++) {
-		auto result = lstate.updated_rows.insert(data[i]);
+		auto result = updated_rows.insert(data[i]);
 		if (result.second == false) {
 			throw InvalidInputException(
 			    "ON CONFLICT DO UPDATE can not update the same row twice in the same command, Ensure that no rows "
@@ -277,20 +304,25 @@ void PhysicalInsert::RegisterUpdatedRows(InsertLocalState &lstate, const Vector
 	}
 }
 
-idx_t PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context,
-                                         InsertLocalState &lstate) const {
-	auto &data_table = table.GetStorage();
-	if (action_type == OnConflictAction::THROW) {
-		data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, nullptr);
-		return 0;
-	}
-	// Check whether any conflicts arise, and if they all meet the conflict_target + condition
-	// If that's not the case - We throw the first error
+template <bool GLOBAL>
+static idx_t HandleInsertConflicts(TableCatalogEntry &table, ExecutionContext &context, InsertLocalState &lstate,
+                                   DataTable &data_table, const PhysicalInsert &op) {
+	auto &types_to_fetch = op.types_to_fetch;
+	auto &on_conflict_condition = op.on_conflict_condition;
+	auto &conflict_target = op.conflict_target;
+	auto &columns_to_fetch = op.columns_to_fetch;
+
+	auto &local_storage = LocalStorage::Get(context.client, data_table.db);
 
 	// We either want to do nothing, or perform an update when conflicts arise
 	ConflictInfo conflict_info(conflict_target);
 	ConflictManager conflict_manager(VerifyExistenceType::APPEND, lstate.insert_chunk.size(), &conflict_info);
-	data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, &conflict_manager);
+	if (GLOBAL) {
+		data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, &conflict_manager);
+	} else {
+		DataTable::VerifyUniqueIndexes(local_storage.GetIndexes(data_table), context.client, lstate.insert_chunk,
+		                               &conflict_manager);
+	}
 	conflict_manager.Finalize();
 	if (conflict_manager.ConflictCount() == 0) {
 		// No conflicts found, 0 updates performed
@@ -309,18 +341,25 @@ idx_t PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionCont
 	conflict_chunk.Slice(conflicts.Selection(), conflicts.Count());
 	conflict_chunk.SetCardinality(conflicts.Count());
 
+	// Holds the pins for the fetched rows
+	unique_ptr<ColumnFetchState> fetch_state;
 	if (!types_to_fetch.empty()) {
 		D_ASSERT(scan_chunk.size() == 0);
 		// When these values are required for the conditions or the SET expressions,
 		// then we scan the existing table for the conflicting tuples, using the rowids
 		scan_chunk.Initialize(context.client, types_to_fetch);
-		auto fetch_state = make_uniq<ColumnFetchState>();
-		auto &transaction = DuckTransaction::Get(context.client, table.catalog);
-		data_table.Fetch(transaction, scan_chunk, columns_to_fetch, row_ids, conflicts.Count(), *fetch_state);
+		fetch_state = make_uniq<ColumnFetchState>();
+		if (GLOBAL) {
+			auto &transaction = DuckTransaction::Get(context.client, table.catalog);
+			data_table.Fetch(transaction, scan_chunk, columns_to_fetch, row_ids, conflicts.Count(), *fetch_state);
+		} else {
+			local_storage.FetchChunk(data_table, row_ids, conflicts.Count(), columns_to_fetch, scan_chunk,
+			                         *fetch_state);
+		}
 	}
 
 	// Splice the Input chunk and the fetched chunk together
-	CombineExistingAndInsertTuples(combined_chunk, scan_chunk, conflict_chunk, context.client);
+	CombineExistingAndInsertTuples(combined_chunk, scan_chunk, conflict_chunk, context.client, op);
 
 	if (on_conflict_condition) {
 		DataChunk conflict_condition_result;
@@ -338,14 +377,19 @@ idx_t PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionCont
 			}
 			combined_chunk.Slice(sel.Selection(), sel.Count());
 			row_ids.Slice(sel.Selection(), sel.Count());
-			data_table.VerifyAppendConstraints(table, context.client, combined_chunk, nullptr);
+			if (GLOBAL) {
+				data_table.VerifyAppendConstraints(table, context.client, combined_chunk, nullptr);
+			} else {
+				DataTable::VerifyUniqueIndexes(local_storage.GetIndexes(data_table), context.client,
+				                               lstate.insert_chunk, nullptr);
+			}
 			throw InternalException("The previous operation was expected to throw but didn't");
 		}
 	}
 
-	RegisterUpdatedRows(lstate, row_ids, combined_chunk.size());
+	RegisterUpdatedRows<GLOBAL>(lstate, row_ids, combined_chunk.size());
 
-	idx_t updated_tuples = PerformOnConflictAction(context, combined_chunk, table, row_ids);
+	idx_t updated_tuples = PerformOnConflictAction<GLOBAL>(context, combined_chunk, table, row_ids, op);
 
 	// Remove the conflicting tuples from the insert chunk
 	SelectionVector sel_vec(lstate.insert_chunk.size());
@@ -356,6 +400,23 @@ idx_t PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionCont
 	return updated_tuples;
 }
 
+idx_t PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context,
+                                         InsertLocalState &lstate) const {
+	auto &data_table = table.GetStorage();
+	if (action_type == OnConflictAction::THROW) {
+		data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, nullptr);
+		return 0;
+	}
+	// Check whether any conflicts arise, and if they all meet the conflict_target + condition
+	// If that's not the case - We throw the first error
+	idx_t updated_tuples = 0;
+	updated_tuples += HandleInsertConflicts<true>(table, context, lstate, data_table, *this);
+	// Also check the transaction-local storage+ART so we can detect conflicts within this transaction
+	updated_tuples += HandleInsertConflicts<false>(table, context, lstate, data_table, *this);
+
+	return updated_tuples;
+}
+
 SinkResultType PhysicalInsert::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
 	auto &gstate = input.global_state.Cast<InsertGlobalState>();
 	auto &lstate = input.local_state.Cast<InsertLocalState>();

package/src/duckdb/src/execution/operator/projection/physical_pivot.cpp

@@ -19,7 +19,7 @@ PhysicalPivot::PhysicalPivot(vector<LogicalType> types_p, unique_ptr<PhysicalOpe
 	for (auto &aggr_expr : bound_pivot.aggregates) {
 		auto &aggr = (BoundAggregateExpression &)*aggr_expr;
 		// for each aggregate, initialize an empty aggregate state and finalize it immediately
-		auto state = make_unsafe_array<data_t>(aggr.function.state_size());
+		auto state = make_unsafe_uniq_array<data_t>(aggr.function.state_size());
 		aggr.function.initialize(state.get());
 		Vector state_vector(Value::POINTER((uintptr_t)state.get()));
 		Vector result_vector(aggr_expr->return_type);

package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp

@@ -17,7 +17,6 @@ PhysicalCreateIndex::PhysicalCreateIndex(LogicalOperator &op, TableCatalogEntry
     : PhysicalOperator(PhysicalOperatorType::CREATE_INDEX, op.types, estimated_cardinality),
       table(table_p.Cast<DuckTableEntry>()), info(std::move(info)),
       unbound_expressions(std::move(unbound_expressions)) {
-	D_ASSERT(table_p.IsDuckTable());
 	// convert virtual column ids to storage column ids
 	for (auto &column_id : column_ids) {
 		storage_ids.push_back(table.GetColumns().LogicalToPhysical(LogicalIndex(column_id)).index);
@@ -136,6 +135,7 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 	auto &schema = table.schema;
 	auto index_entry = schema.CreateIndex(context, *info, table).get();
 	if (!index_entry) {
+		D_ASSERT(info->on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT);
 		// index already exists, but error ignored because of IF NOT EXISTS
 		return SinkFinalizeType::READY;
 	}

package/src/duckdb/src/execution/perfect_aggregate_hashtable.cpp

@@ -23,11 +23,11 @@ PerfectAggregateHashTable::PerfectAggregateHashTable(ClientContext &context, All
 	tuple_size = layout.GetRowWidth();
 
 	// allocate and null initialize the data
-	owned_data = make_unsafe_array<data_t>(tuple_size * total_groups);
+	owned_data = make_unsafe_uniq_array<data_t>(tuple_size * total_groups);
 	data = owned_data.get();
 
 	// set up the empty payloads for every tuple, and initialize the "occupied" flag to false
-	group_is_set = make_unsafe_array<bool>(total_groups);
+	group_is_set = make_unsafe_uniq_array<bool>(total_groups);
 	memset(group_is_set.get(), 0, total_groups * sizeof(bool));
 
 	// initialize the hash table for each entry

package/src/duckdb/src/execution/radix_partitioned_hashtable.cpp

@@ -334,7 +334,7 @@ public:
 	//! The current position to scan the HT for output tuples
 	idx_t ht_index;
 	//! The set of aggregate scan states
-	unsafe_array_ptr<TupleDataParallelScanState> ht_scan_states;
+	unsafe_unique_array<TupleDataParallelScanState> ht_scan_states;
 	atomic<bool> initialized;
 	atomic<bool> finished;
 };
@@ -404,7 +404,7 @@ SourceResultType RadixPartitionedHashTable::GetData(ExecutionContext &context, D
 		for (idx_t i = 0; i < op.aggregates.size(); i++) {
 			D_ASSERT(op.aggregates[i]->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
 			auto &aggr = op.aggregates[i]->Cast<BoundAggregateExpression>();
-			auto aggr_state = make_unsafe_array<data_t>(aggr.function.state_size());
+			auto aggr_state = make_unsafe_uniq_array<data_t>(aggr.function.state_size());
 			aggr.function.initialize(aggr_state.get());
 
 			AggregateInputData aggr_input_data(aggr.bind_info.get(), Allocator::DefaultAllocator());
@@ -433,7 +433,7 @@ SourceResultType RadixPartitionedHashTable::GetData(ExecutionContext &context, D
 		lock_guard<mutex> l(state.lock);
 		if (!state.initialized) {
 			auto &finalized_hts = gstate.finalized_hts;
-			state.ht_scan_states = make_unsafe_array<TupleDataParallelScanState>(finalized_hts.size());
+			state.ht_scan_states = make_unsafe_uniq_array<TupleDataParallelScanState>(finalized_hts.size());
 
 			const auto &layout = gstate.finalized_hts[0]->GetDataCollection().GetLayout();
 			vector<column_t> column_ids;

package/src/duckdb/src/execution/window_segment_tree.cpp

@@ -309,7 +309,7 @@ void WindowSegmentTree::ConstructTree() {
 		level_nodes = (level_nodes + (TREE_FANOUT - 1)) / TREE_FANOUT;
 		internal_nodes += level_nodes;
 	} while (level_nodes > 1);
-	levels_flat_native = make_unsafe_array<data_t>(internal_nodes * state.size());
+	levels_flat_native = make_unsafe_uniq_array<data_t>(internal_nodes * state.size());
 	levels_flat_start.push_back(0);
 
 	idx_t levels_flat_offset = 0;

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -141,7 +141,7 @@ string PragmaImportDatabase(ClientContext &context, const FunctionParameters &pa
 		auto handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK,
 		                          FileSystem::DEFAULT_COMPRESSION);
 		auto fsize = fs.GetFileSize(*handle);
-		auto buffer = make_unsafe_array<char>(fsize);
+		auto buffer = make_unsafe_uniq_array<char>(fsize);
 		fs.Read(*handle, buffer.get(), fsize);
 		auto query = string(buffer.get(), fsize);
 		// Replace the placeholder with the path provided to IMPORT

package/src/duckdb/src/function/scalar/strftime_format.cpp

@@ -408,7 +408,7 @@ string StrfTimeFormat::Format(timestamp_t timestamp, const string &format_str) {
 	auto time = Timestamp::GetTime(timestamp);
 
 	auto len = format.GetLength(date, time, 0, nullptr);
-	auto result = make_unsafe_array<char>(len);
+	auto result = make_unsafe_uniq_array<char>(len);
 	format.FormatString(date, time, result.get());
 	return string(result.get(), len);
 }

package/src/duckdb/src/function/scalar/string/concat.cpp

@@ -118,7 +118,7 @@ static void TemplatedConcatWS(DataChunk &args, string_t *sep_data, const Selecti
                               const SelectionVector &rsel, idx_t count, Vector &result) {
 	vector<idx_t> result_lengths(args.size(), 0);
 	vector<bool> has_results(args.size(), false);
-	auto orrified_data = make_unsafe_array<UnifiedVectorFormat>(args.ColumnCount() - 1);
+	auto orrified_data = make_unsafe_uniq_array<UnifiedVectorFormat>(args.ColumnCount() - 1);
 	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
 		args.data[col_idx].ToUnifiedFormat(args.size(), orrified_data[col_idx - 1]);
 	}

package/src/duckdb/src/function/scalar/string/like.cpp

@@ -395,11 +395,11 @@ bool ILikeOperatorFunction(string_t &str, string_t &pattern, char escape = '\0')
 
 	// lowercase both the str and the pattern
 	idx_t str_llength = LowerFun::LowerLength(str_data, str_size);
-	auto str_ldata = make_unsafe_array<char>(str_llength);
+	auto str_ldata = make_unsafe_uniq_array<char>(str_llength);
 	LowerFun::LowerCase(str_data, str_size, str_ldata.get());
 
 	idx_t pat_llength = LowerFun::LowerLength(pat_data, pat_size);
-	auto pat_ldata = make_unsafe_array<char>(pat_llength);
+	auto pat_ldata = make_unsafe_uniq_array<char>(pat_llength);
 	LowerFun::LowerCase(pat_data, pat_size, pat_ldata.get());
 	string_t str_lcase(str_ldata.get(), str_llength);
 	string_t pat_lcase(pat_ldata.get(), pat_llength);

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -36,12 +36,12 @@ struct ExportAggregateBindData : public FunctionData {
 struct CombineState : public FunctionLocalState {
 	idx_t state_size;
 
-	unsafe_array_ptr<data_t> state_buffer0, state_buffer1;
+	unsafe_unique_array<data_t> state_buffer0, state_buffer1;
 	Vector state_vector0, state_vector1;
 
 	explicit CombineState(idx_t state_size_p)
-	    : state_size(state_size_p), state_buffer0(make_unsafe_array<data_t>(state_size_p)),
-	      state_buffer1(make_unsafe_array<data_t>(state_size_p)),
+	    : state_size(state_size_p), state_buffer0(make_unsafe_uniq_array<data_t>(state_size_p)),
+	      state_buffer1(make_unsafe_uniq_array<data_t>(state_size_p)),
 	      state_vector0(Value::POINTER((uintptr_t)state_buffer0.get())),
 	      state_vector1(Value::POINTER((uintptr_t)state_buffer1.get())) {
 	}
@@ -55,12 +55,12 @@ static unique_ptr<FunctionLocalState> InitCombineState(ExpressionState &state, c
 
 struct FinalizeState : public FunctionLocalState {
 	idx_t state_size;
-	unsafe_array_ptr<data_t> state_buffer;
+	unsafe_unique_array<data_t> state_buffer;
 	Vector addresses;
 
 	explicit FinalizeState(idx_t state_size_p)
 	    : state_size(state_size_p),
-	      state_buffer(make_unsafe_array<data_t>(STANDARD_VECTOR_SIZE * AlignValue(state_size_p))),
+	      state_buffer(make_unsafe_uniq_array<data_t>(STANDARD_VECTOR_SIZE * AlignValue(state_size_p))),
 	      addresses(LogicalType::POINTER) {
 	}
 };

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

@@ -88,7 +88,7 @@ static unique_ptr<FunctionData> WriteCSVBind(ClientContext &context, CopyInfo &i
 	bind_data->is_simple = bind_data->options.delimiter.size() == 1 && bind_data->options.escape.size() == 1 &&
 	                       bind_data->options.quote.size() == 1;
 	if (bind_data->is_simple) {
-		bind_data->requires_quotes = make_unsafe_array<bool>(256);
+		bind_data->requires_quotes = make_unsafe_uniq_array<bool>(256);
 		memset(bind_data->requires_quotes.get(), 0, sizeof(bool) * 256);
 		bind_data->requires_quotes['\n'] = true;
 		bind_data->requires_quotes['\r'] = true;

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-dev3710"
+#define DUCKDB_VERSION "0.7.2-dev3763"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "59a4ec3adc"
+#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/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

@@ -163,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) {