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

package/src/duckdb/src/include/duckdb/storage/data_table.hpp

@@ -193,6 +193,10 @@ public:
 	void VerifyAppendConstraints(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk,
 	                             ConflictManager *conflict_manager = nullptr);
 
+public:
+	static void VerifyUniqueIndexes(TableIndexList &indexes, ClientContext &context, DataChunk &chunk,
+	                                ConflictManager *conflict_manager);
+
 private:
 	//! Verify the new added constraints against current persistent&local data
 	void VerifyNewConstraint(ClientContext &context, DataTable &parent, const BoundConstraint *constraint);

package/src/duckdb/src/include/duckdb/storage/statistics/base_statistics.hpp

@@ -138,7 +138,7 @@ private:
 		StringStatsData string_data;
 	} stats_union;
 	//! Child stats (for LIST and STRUCT)
-	unsafe_array_ptr<BaseStatistics> child_stats;
+	unsafe_unique_array<BaseStatistics> child_stats;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/append_state.hpp

@@ -44,7 +44,7 @@ struct RowGroupAppendState {
 	//! The current row_group we are appending to
 	RowGroup *row_group;
 	//! The column append states
-	unsafe_array_ptr<ColumnAppendState> states;
+	unsafe_unique_array<ColumnAppendState> states;
 	//! Offset within the row_group
 	idx_t offset_in_row_group;
 };

package/src/duckdb/src/include/duckdb/storage/table/row_group.hpp

@@ -149,7 +149,7 @@ public:
 
 private:
 	ChunkInfo *GetChunkInfo(idx_t vector_idx);
-	ColumnData &GetColumn(idx_t c);
+	ColumnData &GetColumn(storage_t c);
 	idx_t GetColumnCount() const;
 	vector<shared_ptr<ColumnData>> &GetColumns();
 

package/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp

@@ -99,7 +99,7 @@ public:
 	//! The maximum row within the row group
 	idx_t max_row_group_row;
 	//! Child column scans
-	unsafe_array_ptr<ColumnScanState> column_scans;
+	unsafe_unique_array<ColumnScanState> column_scans;
 	//! Row group segment tree
 	RowGroupSegmentTree *row_groups;
 	//! The total maximum row index
@@ -109,7 +109,7 @@ public:
 
 public:
 	void Initialize(const vector<LogicalType> &types);
-	const vector<column_t> &GetColumnIds();
+	const vector<storage_t> &GetColumnIds();
 	TableFilterSet *GetFilters();
 	AdaptiveFilter *GetAdaptiveFilter();
 	bool Scan(DuckTransaction &transaction, DataChunk &result);
@@ -130,15 +130,15 @@ public:
 	CollectionScanState local_state;
 
 public:
-	void Initialize(vector<column_t> column_ids, TableFilterSet *table_filters = nullptr);
+	void Initialize(vector<storage_t> column_ids, TableFilterSet *table_filters = nullptr);
 
-	const vector<column_t> &GetColumnIds();
+	const vector<storage_t> &GetColumnIds();
 	TableFilterSet *GetFilters();
 	AdaptiveFilter *GetAdaptiveFilter();
 
 private:
 	//! The column identifiers of the scan
-	vector<column_t> column_ids;
+	vector<storage_t> column_ids;
 	//! The table filters (if any)
 	TableFilterSet *table_filters;
 	//! Adaptive filter info (if any)

package/src/duckdb/src/include/duckdb/storage/table/update_segment.hpp

@@ -96,8 +96,8 @@ private:
 
 struct UpdateNodeData {
 	unique_ptr<UpdateInfo> info;
-	unsafe_array_ptr<sel_t> tuples;
-	unsafe_array_ptr<data_t> tuple_data;
+	unsafe_unique_array<sel_t> tuples;
+	unsafe_unique_array<data_t> tuple_data;
 };
 
 struct UpdateNode {

package/src/duckdb/src/include/duckdb/transaction/local_storage.hpp

@@ -108,7 +108,7 @@ public:
 	//! Initialize a scan of the local storage
 	void InitializeScan(DataTable &table, CollectionScanState &state, optional_ptr<TableFilterSet> table_filters);
 	//! Scan
-	void Scan(CollectionScanState &state, const vector<column_t> &column_ids, DataChunk &result);
+	void Scan(CollectionScanState &state, const vector<storage_t> &column_ids, DataChunk &result);
 
 	void InitializeParallelScan(DataTable &table, ParallelCollectionScanState &state);
 	bool NextParallelScan(ClientContext &context, DataTable &table, ParallelCollectionScanState &state,

package/src/duckdb/src/main/client_context.cpp

@@ -209,7 +209,7 @@ PreservedError ClientContext::EndQueryInternal(ClientContextLock &lock, bool suc
 }
 
 void ClientContext::CleanupInternal(ClientContextLock &lock, BaseQueryResult *result, bool invalidate_transaction) {
-	client_data->http_state = make_uniq<HTTPState>();
+	client_data->http_state = make_shared<HTTPState>();
 	if (!active_query) {
 		// no query currently active
 		return;
@@ -491,7 +491,7 @@ unique_ptr<LogicalOperator> ClientContext::ExtractPlan(const string &query) {
 	}
 
 	unique_ptr<LogicalOperator> plan;
-	client_data->http_state = make_uniq<HTTPState>();
+	client_data->http_state = make_shared<HTTPState>();
 	RunFunctionInTransactionInternal(*lock, [&]() {
 		Planner planner(*this);
 		planner.CreatePlan(std::move(statements[0]));
@@ -934,7 +934,7 @@ void ClientContext::RunFunctionInTransactionInternal(ClientContextLock &lock, co
                                                      bool requires_valid_transaction) {
 	if (requires_valid_transaction && transaction.HasActiveTransaction() &&
 	    ValidChecker::IsInvalidated(ActiveTransaction())) {
-		throw Exception(ErrorManager::FormatException(*this, ErrorType::INVALIDATED_TRANSACTION));
+		throw TransactionException(ErrorManager::FormatException(*this, ErrorType::INVALIDATED_TRANSACTION));
 	}
 	// check if we are on AutoCommit. In this case we should start a transaction
 	bool require_new_transaction = transaction.IsAutoCommit() && !transaction.HasActiveTransaction();
@@ -1013,7 +1013,7 @@ void ClientContext::TryBindRelation(Relation &relation, vector<ColumnDefinition>
 	D_ASSERT(!relation.GetAlias().empty());
 	D_ASSERT(!relation.ToString().empty());
 #endif
-	client_data->http_state = make_uniq<HTTPState>();
+	client_data->http_state = make_shared<HTTPState>();
 	RunFunctionInTransaction([&]() {
 		// bind the expressions
 		auto binder = Binder::CreateBinder(*this);

package/src/duckdb/src/main/db_instance_cache.cpp

@@ -1,8 +1,10 @@
 #include "duckdb/main/db_instance_cache.hpp"
 #include "duckdb/main/extension_helper.hpp"
+
 namespace duckdb {
 
-string GetDBAbsolutePath(const string &database) {
+string GetDBAbsolutePath(const string &database_p) {
+	auto database = FileSystem::ExpandPath(database_p, nullptr);
 	if (database.empty()) {
 		return ":memory:";
 	}
@@ -15,9 +17,9 @@ string GetDBAbsolutePath(const string &database) {
 		return database;
 	}
 	if (FileSystem::IsPathAbsolute(database)) {
-		return database;
+		return FileSystem::NormalizeAbsolutePath(database);
 	}
-	return FileSystem::JoinPath(FileSystem::GetWorkingDirectory(), database);
+	return FileSystem::NormalizeAbsolutePath(FileSystem::JoinPath(FileSystem::GetWorkingDirectory(), database));
 }
 
 shared_ptr<DuckDB> DBInstanceCache::GetInstanceInternal(const string &database, const DBConfig &config) {

package/src/duckdb/src/main/extension/extension_install.cpp

@@ -133,6 +133,23 @@ void ExtensionHelper::InstallExtension(ClientContext &context, const string &ext
 	InstallExtensionInternal(config, &client_config, fs, local_path, extension, force_install);
 }
 
+unsafe_unique_array<data_t> ReadExtensionFileFromDisk(FileSystem &fs, const string &path, idx_t &file_size) {
+	auto source_file = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ);
+	file_size = source_file->GetFileSize();
+	auto in_buffer = make_unsafe_uniq_array<data_t>(file_size);
+	source_file->Read(in_buffer.get(), file_size);
+	source_file->Close();
+	return in_buffer;
+}
+
+void WriteExtensionFileToDisk(FileSystem &fs, const string &path, void *data, idx_t data_size) {
+	auto target_file = fs.OpenFile(path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_APPEND |
+	                                         FileFlags::FILE_FLAGS_FILE_CREATE_NEW);
+	target_file->Write(data, data_size);
+	target_file->Close();
+	target_file.reset();
+}
+
 void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *client_config, FileSystem &fs,
                                                const string &local_path, const string &extension, bool force_install) {
 	if (!config.options.enable_external_access) {
@@ -152,18 +169,9 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 	}
 	auto is_http_url = StringUtil::Contains(extension, "http://");
 	if (fs.FileExists(extension)) {
-
-		std::ifstream in(extension, std::ios::binary);
-		if (in.bad()) {
-			throw IOException("Failed to read extension from \"%s\"", extension);
-		}
-		std::ofstream out(temp_path, std::ios::binary);
-		out << in.rdbuf();
-		if (out.bad()) {
-			throw IOException("Failed to write extension to \"%s\"", temp_path);
-		}
-		in.close();
-		out.close();
+		idx_t file_size;
+		auto in_buffer = ReadExtensionFileFromDisk(fs, extension, file_size);
+		WriteExtensionFileToDisk(fs, temp_path, in_buffer.get(), file_size);
 
 		fs.MoveFile(temp_path, local_extension_path);
 		return;
@@ -225,12 +233,8 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 		}
 	}
 	auto decompressed_body = GZipFileSystem::UncompressGZIPString(res->body);
-	std::ofstream out(temp_path, std::ios::binary);
-	out.write(decompressed_body.data(), decompressed_body.size());
-	if (out.bad()) {
-		throw IOException("Failed to write extension to %s", temp_path);
-	}
-	out.close();
+
+	WriteExtensionFileToDisk(fs, temp_path, (void *)decompressed_body.data(), decompressed_body.size());
 	fs.MoveFile(temp_path, local_extension_path);
 #endif
 }

package/src/duckdb/src/optimizer/join_order/join_relation_set.cpp

@@ -35,7 +35,7 @@ bool JoinRelationSet::IsSubset(JoinRelationSet &super, JoinRelationSet &sub) {
 	return false;
 }
 
-JoinRelationSet &JoinRelationSetManager::GetJoinRelation(unsafe_array_ptr<idx_t> relations, idx_t count) {
+JoinRelationSet &JoinRelationSetManager::GetJoinRelation(unsafe_unique_array<idx_t> relations, idx_t count) {
 	// now look it up in the tree
 	reference<JoinRelationTreeNode> info(root);
 	for (idx_t i = 0; i < count; i++) {
@@ -59,7 +59,7 @@ JoinRelationSet &JoinRelationSetManager::GetJoinRelation(unsafe_array_ptr<idx_t>
 //! Create or get a JoinRelationSet from a single node with the given index
 JoinRelationSet &JoinRelationSetManager::GetJoinRelation(idx_t index) {
 	// create a sorted vector of the relations
-	auto relations = make_unsafe_array<idx_t>(1);
+	auto relations = make_unsafe_uniq_array<idx_t>(1);
 	relations[0] = index;
 	idx_t count = 1;
 	return GetJoinRelation(std::move(relations), count);
@@ -67,7 +67,7 @@ JoinRelationSet &JoinRelationSetManager::GetJoinRelation(idx_t index) {
 
 JoinRelationSet &JoinRelationSetManager::GetJoinRelation(unordered_set<idx_t> &bindings) {
 	// create a sorted vector of the relations
-	unsafe_array_ptr<idx_t> relations = bindings.empty() ? nullptr : make_unsafe_array<idx_t>(bindings.size());
+	unsafe_unique_array<idx_t> relations = bindings.empty() ? nullptr : make_unsafe_uniq_array<idx_t>(bindings.size());
 	idx_t count = 0;
 	for (auto &entry : bindings) {
 		relations[count++] = entry;
@@ -77,7 +77,7 @@ JoinRelationSet &JoinRelationSetManager::GetJoinRelation(unordered_set<idx_t> &b
 }
 
 JoinRelationSet &JoinRelationSetManager::Union(JoinRelationSet &left, JoinRelationSet &right) {
-	auto relations = make_unsafe_array<idx_t>(left.count + right.count);
+	auto relations = make_unsafe_uniq_array<idx_t>(left.count + right.count);
 	idx_t count = 0;
 	// move through the left and right relations, eliminating duplicates
 	idx_t i = 0, j = 0;
@@ -113,7 +113,7 @@ JoinRelationSet &JoinRelationSetManager::Union(JoinRelationSet &left, JoinRelati
 }
 
 // JoinRelationSet *JoinRelationSetManager::Difference(JoinRelationSet *left, JoinRelationSet *right) {
-// 	auto relations = unsafe_array_ptr<idx_t>(new idx_t[left->count]);
+// 	auto relations = unsafe_unique_array<idx_t>(new idx_t[left->count]);
 // 	idx_t count = 0;
 // 	// move through the left and right relations
 // 	idx_t i = 0, j = 0;

package/src/duckdb/src/parser/expression/collate_expression.cpp

@@ -15,7 +15,7 @@ CollateExpression::CollateExpression(string collation_p, unique_ptr<ParsedExpres
 }
 
 string CollateExpression::ToString() const {
-	return child->ToString() + " COLLATE " + KeywordHelper::WriteOptionallyQuoted(collation);
+	return StringUtil::Format("%s COLLATE %s", child->ToString(), SQLIdentifier(collation));
 }
 
 bool CollateExpression::Equal(const CollateExpression *a, const CollateExpression *b) {

package/src/duckdb/src/parser/keyword_helper.cpp

@@ -29,11 +29,21 @@ bool KeywordHelper::RequiresQuotes(const string &text, bool allow_caps) {
 	return IsKeyword(text);
 }
 
+string KeywordHelper::EscapeQuotes(const string &text, char quote) {
+	return StringUtil::Replace(text, string(1, quote), string(2, quote));
+}
+
+string KeywordHelper::WriteQuoted(const string &text, char quote) {
+	// 1. Escapes all occurences of 'quote' by doubling them (escape in SQL)
+	// 2. Adds quotes around the string
+	return string(1, quote) + EscapeQuotes(text) + string(1, quote);
+}
+
 string KeywordHelper::WriteOptionallyQuoted(const string &text, char quote, bool allow_caps) {
 	if (!RequiresQuotes(text, allow_caps)) {
 		return text;
 	}
-	return string(1, quote) + StringUtil::Replace(text, string(1, quote), string(2, quote)) + string(1, quote);
+	return WriteQuoted(text, quote);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/query_node/select_node.cpp

@@ -39,7 +39,7 @@ string SelectNode::ToString() const {
 		}
 		result += select_list[i]->ToString();
 		if (!select_list[i]->alias.empty()) {
-			result += " AS " + KeywordHelper::WriteOptionallyQuoted(select_list[i]->alias);
+			result += StringUtil::Format(" AS %s", SQLIdentifier(select_list[i]->alias));
 		}
 	}
 	if (from_table && from_table->type != TableReferenceType::EMPTY) {

package/src/duckdb/src/parser/statement/copy_statement.cpp

@@ -86,7 +86,7 @@ string CopyStatement::ToString() const {
 		D_ASSERT(!select_statement);
 		result += TablePart(*info);
 		result += " FROM";
-		result += StringUtil::Format(" '%s'", info->file_path);
+		result += StringUtil::Format(" %s", SQLString(info->file_path));
 		result += CopyOptionsToString(info->format, info->options);
 	} else {
 		if (select_statement) {
@@ -96,7 +96,7 @@ string CopyStatement::ToString() const {
 			result += TablePart(*info);
 		}
 		result += " TO ";
-		result += StringUtil::Format("'%s'", info->file_path);
+		result += StringUtil::Format("%s", SQLString(info->file_path));
 		result += CopyOptionsToString(info->format, info->options);
 	}
 	return result;

package/src/duckdb/src/parser/tableref.cpp

@@ -16,7 +16,7 @@ string TableRef::BaseToString(string result) const {
 
 string TableRef::BaseToString(string result, const vector<string> &column_name_alias) const {
 	if (!alias.empty()) {
-		result += " AS " + KeywordHelper::WriteOptionallyQuoted(alias);
+		result += StringUtil::Format(" AS %s", SQLIdentifier(alias));
 	}
 	if (!column_name_alias.empty()) {
 		D_ASSERT(!alias.empty());

package/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp

@@ -94,7 +94,13 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 			for (auto &scan : config.replacement_scans) {
 				auto replacement_function = scan.function(context, table_name, scan.data.get());
 				if (replacement_function) {
-					replacement_function->alias = ref.alias.empty() ? replacement_function->alias : ref.alias;
+					if (!ref.alias.empty()) {
+						// user-provided alias overrides the default alias
+						replacement_function->alias = ref.alias;
+					} else if (replacement_function->alias.empty()) {
+						// if the replacement scan itself did not provide an alias we use the table name
+						replacement_function->alias = ref.table_name;
+					}
 					if (replacement_function->type == TableReferenceType::TABLE_FUNCTION) {
 						auto &table_function = replacement_function->Cast<TableFunctionRef>();
 						table_function.column_name_alias = ref.column_name_alias;

package/src/duckdb/src/planner/expression_binder/index_binder.cpp

@@ -40,7 +40,7 @@ BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, i
 				throw InternalException("failed to replay CREATE INDEX statement - column id not found");
 			}
 			return BindResult(
-			    make_uniq<BoundColumnRefExpression>(col_ref.alias, col_type, ColumnBinding(0, col_id_idx)));
+			    make_uniq<BoundColumnRefExpression>(col_ref.GetColumnName(), col_type, ColumnBinding(0, col_id_idx)));
 		}
 		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	}

package/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp

@@ -32,7 +32,7 @@ void WriteOverflowStringsToDisk::WriteString(string_t string, block_id_t &result
 	MiniZStream s;
 	size_t compressed_size = 0;
 	compressed_size = s.MaxCompressedLength(uncompressed_size);
-	auto compressed_buf = make_unsafe_array<data_t>(compressed_size);
+	auto compressed_buf = make_unsafe_uniq_array<data_t>(compressed_size);
 	s.Compress((const char *)string.GetData(), uncompressed_size, (char *)compressed_buf.get(), &compressed_size);
 	string_t compressed_string((const char *)compressed_buf.get(), compressed_size);
 

package/src/duckdb/src/storage/compression/string_uncompressed.cpp

@@ -292,13 +292,13 @@ string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, V
 		offset += 2 * sizeof(uint32_t);
 
 		data_ptr_t decompression_ptr;
-		unsafe_array_ptr<data_t> decompression_buffer;
+		unsafe_unique_array<data_t> decompression_buffer;
 
 		// If string is in single block we decompress straight from it, else we copy first
 		if (remaining <= Storage::BLOCK_SIZE - sizeof(block_id_t) - offset) {
 			decompression_ptr = handle.Ptr() + offset;
 		} else {
-			decompression_buffer = make_unsafe_array<data_t>(compressed_size);
+			decompression_buffer = make_unsafe_uniq_array<data_t>(compressed_size);
 			auto target_ptr = decompression_buffer.get();
 
 			// now append the string to the single buffer

package/src/duckdb/src/storage/data_table.cpp

@@ -530,6 +530,75 @@ void DataTable::VerifyNewConstraint(ClientContext &context, DataTable &parent, c
 	local_storage.VerifyNewConstraint(parent, *constraint);
 }
 
+bool HasUniqueIndexes(TableIndexList &list) {
+	bool has_unique_index = false;
+	list.Scan([&](Index &index) {
+		if (index.IsUnique()) {
+			return has_unique_index = true;
+			return true;
+		}
+		return false;
+	});
+	return has_unique_index;
+}
+
+void DataTable::VerifyUniqueIndexes(TableIndexList &indexes, ClientContext &context, DataChunk &chunk,
+                                    ConflictManager *conflict_manager) {
+	//! check whether or not the chunk can be inserted into the indexes
+	if (!conflict_manager) {
+		// Only need to verify that no unique constraints are violated
+		indexes.Scan([&](Index &index) {
+			if (!index.IsUnique()) {
+				return false;
+			}
+			index.VerifyAppend(chunk);
+			return false;
+		});
+		return;
+	}
+
+	D_ASSERT(conflict_manager);
+	// The conflict manager is only provided when a ON CONFLICT clause was provided to the INSERT statement
+
+	idx_t matching_indexes = 0;
+	auto &conflict_info = conflict_manager->GetConflictInfo();
+	// First we figure out how many indexes match our conflict target
+	// So we can optimize accordingly
+	indexes.Scan([&](Index &index) {
+		matching_indexes += conflict_info.ConflictTargetMatches(index);
+		return false;
+	});
+	conflict_manager->SetMode(ConflictManagerMode::SCAN);
+	conflict_manager->SetIndexCount(matching_indexes);
+	// First we verify only the indexes that match our conflict target
+	unordered_set<Index *> checked_indexes;
+	indexes.Scan([&](Index &index) {
+		if (!index.IsUnique()) {
+			return false;
+		}
+		if (conflict_info.ConflictTargetMatches(index)) {
+			index.VerifyAppend(chunk, *conflict_manager);
+			checked_indexes.insert(&index);
+		}
+		return false;
+	});
+
+	conflict_manager->SetMode(ConflictManagerMode::THROW);
+	// Then we scan the other indexes, throwing if they cause conflicts on tuples that were not found during
+	// the scan
+	indexes.Scan([&](Index &index) {
+		if (!index.IsUnique()) {
+			return false;
+		}
+		if (checked_indexes.count(&index)) {
+			// Already checked this constraint
+			return false;
+		}
+		index.VerifyAppend(chunk, *conflict_manager);
+		return false;
+	});
+}
+
 void DataTable::VerifyAppendConstraints(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk,
                                         ConflictManager *conflict_manager) {
 	if (table.HasGeneratedColumns()) {
@@ -548,6 +617,11 @@ void DataTable::VerifyAppendConstraints(TableCatalogEntry &table, ClientContext
 			VerifyGeneratedExpressionSuccess(context, table, chunk, *bound_expression, col.Oid());
 		}
 	}
+
+	if (HasUniqueIndexes(info->indexes)) {
+		VerifyUniqueIndexes(info->indexes, context, chunk, conflict_manager);
+	}
+
 	auto &constraints = table.GetConstraints();
 	auto &bound_constraints = table.GetBoundConstraints();
 	for (idx_t i = 0; i < bound_constraints.size(); i++) {
@@ -567,50 +641,7 @@ void DataTable::VerifyAppendConstraints(TableCatalogEntry &table, ClientContext
 			break;
 		}
 		case ConstraintType::UNIQUE: {
-			//! check whether or not the chunk can be inserted into the indexes
-			if (conflict_manager) {
-				// This is only provided when a ON CONFLICT clause was provided
-				idx_t matching_indexes = 0;
-				auto &conflict_info = conflict_manager->GetConflictInfo();
-				// First we figure out how many indexes match our conflict target
-				// So we can optimize accordingly
-				info->indexes.Scan([&](Index &index) {
-					matching_indexes += conflict_info.ConflictTargetMatches(index);
-					return false;
-				});
-				conflict_manager->SetMode(ConflictManagerMode::SCAN);
-				conflict_manager->SetIndexCount(matching_indexes);
-				// First we verify only the indexes that match our conflict target
-				info->indexes.Scan([&](Index &index) {
-					if (!index.IsUnique()) {
-						return false;
-					}
-					if (conflict_info.ConflictTargetMatches(index)) {
-						index.VerifyAppend(chunk, *conflict_manager);
-					}
-					return false;
-				});
-
-				conflict_manager->SetMode(ConflictManagerMode::THROW);
-				// Then we scan the other indexes, throwing if they cause conflicts on tuples that were not found during
-				// the scan
-				info->indexes.Scan([&](Index &index) {
-					if (!index.IsUnique()) {
-						return false;
-					}
-					index.VerifyAppend(chunk, *conflict_manager);
-					return false;
-				});
-			} else {
-				// Only need to verify that no unique constraints are violated
-				info->indexes.Scan([&](Index &index) {
-					if (!index.IsUnique()) {
-						return false;
-					}
-					index.VerifyAppend(chunk);
-					return false;
-				});
-			}
+			// These were handled earlier on
 			break;
 		}
 		case ConstraintType::FOREIGN_KEY: {

package/src/duckdb/src/storage/local_storage.cpp

@@ -310,7 +310,7 @@ void LocalStorage::InitializeScan(DataTable &table, CollectionScanState &state,
 	storage->InitializeScan(state, table_filters);
 }
 
-void LocalStorage::Scan(CollectionScanState &state, const vector<column_t> &column_ids, DataChunk &result) {
+void LocalStorage::Scan(CollectionScanState &state, const vector<storage_t> &column_ids, DataChunk &result) {
 	state.Scan(transaction, result);
 }
 

package/src/duckdb/src/storage/statistics/list_stats.cpp

@@ -7,7 +7,7 @@
 namespace duckdb {
 
 void ListStats::Construct(BaseStatistics &stats) {
-	stats.child_stats = unsafe_array_ptr<BaseStatistics>(new BaseStatistics[1]);
+	stats.child_stats = unsafe_unique_array<BaseStatistics>(new BaseStatistics[1]);
 	BaseStatistics::Construct(stats.child_stats[0], ListType::GetChildType(stats.GetType()));
 }
 

package/src/duckdb/src/storage/statistics/struct_stats.cpp

@@ -7,7 +7,7 @@ namespace duckdb {
 
 void StructStats::Construct(BaseStatistics &stats) {
 	auto &child_types = StructType::GetChildTypes(stats.GetType());
-	stats.child_stats = unsafe_array_ptr<BaseStatistics>(new BaseStatistics[child_types.size()]);
+	stats.child_stats = unsafe_unique_array<BaseStatistics>(new BaseStatistics[child_types.size()]);
 	for (idx_t i = 0; i < child_types.size(); i++) {
 		BaseStatistics::Construct(stats.child_stats[i], child_types[i].second);
 	}

package/src/duckdb/src/storage/storage_manager.cpp

@@ -19,6 +19,9 @@ StorageManager::StorageManager(AttachedDatabase &db, string path_p, bool read_on
     : db(db), path(std::move(path_p)), read_only(read_only) {
 	if (path.empty()) {
 		path = ":memory:";
+	} else {
+		auto &fs = FileSystem::Get(db);
+		this->path = fs.ExpandPath(path);
 	}
 }