duckdb 1.4.0 → 1.4.1

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

@@ -71,6 +71,8 @@ struct StringStats {
 	                                                     ExpressionType comparison_type, const string &value);
 
 	DUCKDB_API static void Update(BaseStatistics &stats, const string_t &value);
+	DUCKDB_API static void SetMin(BaseStatistics &stats, const string_t &value);
+	DUCKDB_API static void SetMax(BaseStatistics &stats, const string_t &value);
 	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);
 	DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
 

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

@@ -48,10 +48,10 @@ public:
 	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
 	void FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
 	              idx_t result_idx) override;
-	void Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	            idx_t update_count) override;
-	void UpdateColumn(TransactionData transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
+	void Update(TransactionData transaction, DataTable &data_table, idx_t column_index, Vector &update_vector,
+	            row_t *row_ids, idx_t update_count) override;
+	void UpdateColumn(TransactionData transaction, DataTable &data_table, const vector<column_t> &column_path,
+	                  Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) override;
 	unique_ptr<BaseStatistics> GetUpdateStatistics() override;
 
 	void CommitDropColumn() override;

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

@@ -154,10 +154,10 @@ public:
 	virtual void FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
 	                      idx_t result_idx);
 
-	virtual void Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	                    idx_t update_count);
-	virtual void UpdateColumn(TransactionData transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                          row_t *row_ids, idx_t update_count, idx_t depth);
+	virtual void Update(TransactionData transaction, DataTable &data_table, idx_t column_index, Vector &update_vector,
+	                    row_t *row_ids, idx_t update_count);
+	virtual void UpdateColumn(TransactionData transaction, DataTable &data_table, const vector<column_t> &column_path,
+	                          Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth);
 	virtual unique_ptr<BaseStatistics> GetUpdateStatistics();
 
 	virtual void CommitDropColumn();
@@ -217,8 +217,8 @@ protected:
 	void FetchUpdates(TransactionData transaction, idx_t vector_index, Vector &result, idx_t scan_count,
 	                  bool allow_updates, bool scan_committed);
 	void FetchUpdateRow(TransactionData transaction, row_t row_id, Vector &result, idx_t result_idx);
-	void UpdateInternal(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	                    idx_t update_count, Vector &base_vector);
+	void UpdateInternal(TransactionData transaction, DataTable &data_table, idx_t column_index, Vector &update_vector,
+	                    row_t *row_ids, idx_t update_count, Vector &base_vector);
 	idx_t FetchUpdateData(ColumnScanState &state, row_t *row_ids, Vector &base_vector);
 
 	idx_t GetVectorCount(idx_t vector_index) const;

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

@@ -46,10 +46,10 @@ public:
 	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
 	void FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
 	              idx_t result_idx) override;
-	void Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	            idx_t update_count) override;
-	void UpdateColumn(TransactionData transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
+	void Update(TransactionData transaction, DataTable &data_table, idx_t column_index, Vector &update_vector,
+	            row_t *row_ids, idx_t update_count) override;
+	void UpdateColumn(TransactionData transaction, DataTable &data_table, const vector<column_t> &column_path,
+	                  Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) override;
 	unique_ptr<BaseStatistics> GetUpdateStatistics() override;
 
 	void CommitDropColumn() override;

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

@@ -160,12 +160,12 @@ public:
 	void InitializeAppend(RowGroupAppendState &append_state);
 	void Append(RowGroupAppendState &append_state, DataChunk &chunk, idx_t append_count);
 
-	void Update(TransactionData transaction, DataChunk &updates, row_t *ids, idx_t offset, idx_t count,
-	            const vector<PhysicalIndex> &column_ids);
+	void Update(TransactionData transaction, DataTable &data_table, DataChunk &updates, row_t *ids, idx_t offset,
+	            idx_t count, const vector<PhysicalIndex> &column_ids);
 	//! Update a single column; corresponds to DataTable::UpdateColumn
 	//! This method should only be called from the WAL
-	void UpdateColumn(TransactionData transaction, DataChunk &updates, Vector &row_ids, idx_t offset, idx_t count,
-	                  const vector<column_t> &column_path);
+	void UpdateColumn(TransactionData transaction, DataTable &data_table, DataChunk &updates, Vector &row_ids,
+	                  idx_t offset, idx_t count, const vector<column_t> &column_path);
 
 	void MergeStatistics(idx_t column_idx, const BaseStatistics &other);
 	void MergeIntoStatistics(idx_t column_idx, BaseStatistics &other);

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

@@ -36,6 +36,7 @@ struct CollectionCheckpointState;
 struct PersistentCollectionData;
 class CheckpointTask;
 class TableIOManager;
+class DataTable;
 
 class RowGroupCollection {
 public:
@@ -99,9 +100,10 @@ public:
 	void RemoveFromIndexes(TableIndexList &indexes, Vector &row_identifiers, idx_t count);
 
 	idx_t Delete(TransactionData transaction, DataTable &table, row_t *ids, idx_t count);
-	void Update(TransactionData transaction, row_t *ids, const vector<PhysicalIndex> &column_ids, DataChunk &updates);
-	void UpdateColumn(TransactionData transaction, Vector &row_ids, const vector<column_t> &column_path,
-	                  DataChunk &updates);
+	void Update(TransactionData transaction, DataTable &table, row_t *ids, const vector<PhysicalIndex> &column_ids,
+	            DataChunk &updates);
+	void UpdateColumn(TransactionData transaction, DataTable &table, Vector &row_ids,
+	                  const vector<column_t> &column_path, DataChunk &updates);
 
 	void Checkpoint(TableDataWriter &writer, TableStatistics &global_stats);
 

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

@@ -48,10 +48,10 @@ public:
 	void AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata, idx_t count) override;
 	void RevertAppend(row_t start_row) override;
 
-	void Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	            idx_t update_count) override;
-	void UpdateColumn(TransactionData transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
+	void Update(TransactionData transaction, DataTable &data_table, idx_t column_index, Vector &update_vector,
+	            row_t *row_ids, idx_t update_count) override;
+	void UpdateColumn(TransactionData transaction, DataTable &data_table, const vector<column_t> &column_path,
+	                  Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) override;
 
 	void CommitDropColumn() override;
 

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

@@ -47,10 +47,10 @@ public:
 	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
 	void FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
 	              idx_t result_idx) override;
-	void Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	            idx_t update_count) override;
-	void UpdateColumn(TransactionData transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
+	void Update(TransactionData transaction, DataTable &data_table, idx_t column_index, Vector &update_vector,
+	            row_t *row_ids, idx_t update_count) override;
+	void UpdateColumn(TransactionData transaction, DataTable &data_table, const vector<column_t> &column_path,
+	                  Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) override;
 	unique_ptr<BaseStatistics> GetUpdateStatistics() override;
 
 	void CommitDropColumn() override;

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

@@ -46,10 +46,10 @@ public:
 	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
 	void FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
 	              idx_t result_idx) override;
-	void Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	            idx_t update_count) override;
-	void UpdateColumn(TransactionData transaction, const vector<column_t> &column_path, Vector &update_vector,
-	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
+	void Update(TransactionData transaction, DataTable &data_table, idx_t column_index, Vector &update_vector,
+	            row_t *row_ids, idx_t update_count) override;
+	void UpdateColumn(TransactionData transaction, DataTable &data_table, const vector<column_t> &column_path,
+	                  Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) override;
 	unique_ptr<BaseStatistics> GetUpdateStatistics() override;
 
 	void CommitDropColumn() override;

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

@@ -38,8 +38,8 @@ public:
 	void FetchUpdates(TransactionData transaction, idx_t vector_index, Vector &result);
 	void FetchCommitted(idx_t vector_index, Vector &result);
 	void FetchCommittedRange(idx_t start_row, idx_t count, Vector &result);
-	void Update(TransactionData transaction, idx_t column_index, Vector &update, row_t *ids, idx_t count,
-	            Vector &base_data);
+	void Update(TransactionData transaction, DataTable &data_table, idx_t column_index, Vector &update, row_t *ids,
+	            idx_t count, Vector &base_data);
 	void FetchRow(TransactionData transaction, idx_t row_id, Vector &result, idx_t result_idx);
 
 	void RollbackUpdate(UpdateInfo &info);

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

@@ -76,7 +76,7 @@ public:
 	                idx_t base_row);
 	void PushSequenceUsage(SequenceCatalogEntry &entry, const SequenceData &data);
 	void PushAppend(DataTable &table, idx_t row_start, idx_t row_count);
-	UndoBufferReference CreateUpdateInfo(idx_t type_size, idx_t entries);
+	UndoBufferReference CreateUpdateInfo(idx_t type_size, DataTable &data_table, idx_t entries);
 
 	bool IsDuckTransaction() const override {
 		return true;
@@ -90,6 +90,7 @@ public:
 	//! Get a shared lock on a table
 	shared_ptr<CheckpointLock> SharedLockTable(DataTableInfo &info);
 
+	//! Hold an owning reference of the table, needed to safely reference it inside the transaction commit/undo logic
 	void ModifyTable(DataTable &tbl);
 
 private:

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

@@ -17,6 +17,7 @@
 namespace duckdb {
 class UpdateSegment;
 struct DataTableInfo;
+class DataTable;
 
 //! UpdateInfo is a class that represents a set of updates applied to a single vector.
 //! The UpdateInfo struct contains metadata associated with the update.
@@ -26,6 +27,8 @@ struct DataTableInfo;
 struct UpdateInfo {
 	//! The update segment that this update info affects
 	UpdateSegment *segment;
+	//! The table this was update was made on
+	DataTable *table;
 	//! The column index of which column we are updating
 	idx_t column_index;
 	//! The version number
@@ -87,7 +90,7 @@ struct UpdateInfo {
 	//! Returns the total allocation size for an UpdateInfo entry, together with space for the tuple data
 	static idx_t GetAllocSize(idx_t type_size);
 	//! Initialize an UpdateInfo struct that has been allocated using GetAllocSize (i.e. has extra space after it)
-	static void Initialize(UpdateInfo &info, transaction_t transaction_id);
+	static void Initialize(UpdateInfo &info, DataTable &data_table, transaction_t transaction_id);
 };
 
 } // namespace duckdb

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

@@ -31,7 +31,7 @@ public:
 	void CommitEntry(UndoFlags type, data_ptr_t data);
 
 private:
-	void SwitchTable(DataTableInfo *table, UndoFlags new_op);
+	void SwitchTable(DataTableInfo &table, UndoFlags new_op);
 
 	void WriteCatalogEntry(CatalogEntry &entry, data_ptr_t extra_data);
 	void WriteDelete(DeleteInfo &info);

package/src/duckdb/src/logging/log_types.cpp

@@ -1,3 +1,4 @@
+#include "duckdb/main/attached_database.hpp"
 #include "duckdb/logging/file_system_logger.hpp"
 #include "duckdb/logging/log_type.hpp"
 #include "duckdb/common/file_opener.hpp"
@@ -13,7 +14,18 @@ constexpr LogLevel FileSystemLogType::LEVEL;
 constexpr LogLevel QueryLogType::LEVEL;
 constexpr LogLevel HTTPLogType::LEVEL;
 constexpr LogLevel PhysicalOperatorLogType::LEVEL;
+constexpr LogLevel CheckpointLogType::LEVEL;
 
+//===--------------------------------------------------------------------===//
+// QueryLogType
+//===--------------------------------------------------------------------===//
+string QueryLogType::ConstructLogMessage(const string &str) {
+	return str;
+}
+
+//===--------------------------------------------------------------------===//
+// FileSystemLogType
+//===--------------------------------------------------------------------===//
 FileSystemLogType::FileSystemLogType() : LogType(NAME, LEVEL, GetLogType()) {
 }
 
@@ -36,6 +48,9 @@ LogicalType FileSystemLogType::GetLogType() {
 	return LogicalType::STRUCT(child_list);
 }
 
+//===--------------------------------------------------------------------===//
+// HTTPLogType
+//===--------------------------------------------------------------------===//
 HTTPLogType::HTTPLogType() : LogType(NAME, LEVEL, GetLogType()) {
 }
 
@@ -92,6 +107,9 @@ string HTTPLogType::ConstructLogMessage(BaseRequest &request, optional_ptr<HTTPR
 	return Value::STRUCT(child_list).ToString();
 }
 
+//===--------------------------------------------------------------------===//
+// PhysicalOperatorLogType
+//===--------------------------------------------------------------------===//
 PhysicalOperatorLogType::PhysicalOperatorLogType() : LogType(NAME, LEVEL, GetLogType()) {
 }
 
@@ -129,5 +147,50 @@ string PhysicalOperatorLogType::ConstructLogMessage(const PhysicalOperator &phys
 
 	return Value::STRUCT(std::move(child_list)).ToString();
 }
+//===--------------------------------------------------------------------===//
+// CheckpointLogType
+//===--------------------------------------------------------------------===//
+CheckpointLogType::CheckpointLogType() : LogType(NAME, LEVEL, GetLogType()) {
+}
+
+LogicalType CheckpointLogType::GetLogType() {
+	child_list_t<LogicalType> child_list = {
+	    {"database", LogicalType::VARCHAR},
+	    {"schema", LogicalType::VARCHAR},
+	    {"table", LogicalType::VARCHAR},
+	    {"type", LogicalType::VARCHAR},
+	    {"info", LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR)},
+	};
+	return LogicalType::STRUCT(child_list);
+}
+
+string CheckpointLogType::CreateLog(const AttachedDatabase &db, DataTableInfo &table, const char *op_name,
+                                    vector<Value> map_keys, vector<Value> map_values) {
+	child_list_t<Value> child_list = {
+	    {"database", db.name},
+	    {"schema", table.GetSchemaName()},
+	    {"table", table.GetTableName()},
+	    {"type", op_name},
+	    {"info", Value::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR, std::move(map_keys), std::move(map_values))},
+	};
+
+	return Value::STRUCT(std::move(child_list)).ToString();
+}
+
+string CheckpointLogType::ConstructLogMessage(const AttachedDatabase &db, DataTableInfo &table, idx_t segment_idx,
+                                              idx_t merge_count, idx_t target_count, idx_t merge_rows,
+                                              idx_t row_start) {
+	vector<Value> map_keys = {"segment_idx", "merge_count", "target_count", "merge_rows", "row_start"};
+	vector<Value> map_values = {to_string(segment_idx), to_string(merge_count), to_string(target_count),
+	                            to_string(merge_rows), to_string(row_start)};
+	return CreateLog(db, table, "vacuum", std::move(map_keys), std::move(map_values));
+}
+
+string CheckpointLogType::ConstructLogMessage(const AttachedDatabase &db, DataTableInfo &table, idx_t segment_idx,
+                                              RowGroup &row_group) {
+	vector<Value> map_keys = {"segment_idx", "start", "count"};
+	vector<Value> map_values = {to_string(segment_idx), to_string(row_group.start), to_string(row_group.count.load())};
+	return CreateLog(db, table, "checkpoint", std::move(map_keys), std::move(map_values));
+}
 
 } // namespace duckdb

package/src/duckdb/src/main/attached_database.cpp

@@ -22,6 +22,10 @@ StoredDatabasePath::~StoredDatabasePath() {
 	manager.EraseDatabasePath(path);
 }
 
+void StoredDatabasePath::OnDetach() {
+	manager.DetachDatabase(path);
+}
+
 //===--------------------------------------------------------------------===//
 // Attach Options
 //===--------------------------------------------------------------------===//
@@ -155,6 +159,13 @@ bool AttachedDatabase::NameIsReserved(const string &name) {
 	return name == DEFAULT_SCHEMA || name == TEMP_CATALOG || name == SYSTEM_CATALOG;
 }
 
+string AttachedDatabase::StoredPath() const {
+	if (stored_database_path) {
+		return stored_database_path->path;
+	}
+	return string();
+}
+
 static string RemoveQueryParams(const string &name) {
 	auto vec = StringUtil::Split(name, "?");
 	D_ASSERT(!vec.empty());
@@ -227,10 +238,12 @@ void AttachedDatabase::SetReadOnlyDatabase() {
 }
 
 void AttachedDatabase::OnDetach(ClientContext &context) {
-	if (!catalog) {
-		return;
+	if (catalog) {
+		catalog->OnDetach(context);
+	}
+	if (stored_database_path) {
+		stored_database_path->OnDetach();
 	}
-	catalog->OnDetach(context);
 }
 
 void AttachedDatabase::Close() {

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

@@ -217,15 +217,15 @@ void ClientContext::BeginQueryInternal(ClientContextLock &lock, const string &qu
 		state->QueryBegin(*this);
 	}
 
-	// Flush the old Logger
+	// Flush the old logger.
 	logger->Flush();
 
-	// Refresh the logger to ensure we are in sync with global log settings
-	LoggingContext context(LogContextScope::CONNECTION);
-	context.connection_id = connection_id;
-	context.transaction_id = transaction.ActiveTransaction().global_transaction_id;
-	context.query_id = transaction.GetActiveQuery();
-	logger = db->GetLogManager().CreateLogger(context, true);
+	// Refresh the logger to ensure we are in sync with the global log settings.
+	LoggingContext logging_context(LogContextScope::CONNECTION);
+	logging_context.connection_id = connection_id;
+	logging_context.transaction_id = transaction.ActiveTransaction().global_transaction_id;
+	logging_context.query_id = transaction.GetActiveQuery();
+	logger = db->GetLogManager().CreateLogger(logging_context, true);
 	DUCKDB_LOG(*this, QueryLogType, query);
 }
 
@@ -889,6 +889,10 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
     shared_ptr<PreparedStatementData> &prepared, const PendingQueryParameters &parameters) {
 	unique_ptr<PendingQueryResult> pending;
 
+	// Start the profiler.
+	auto &profiler = QueryProfiler::Get(*this);
+	profiler.StartQuery(query, IsExplainAnalyze(statement ? statement.get() : prepared->unbound_statement.get()));
+
 	try {
 		BeginQueryInternal(lock, query);
 	} catch (std::exception &ex) {
@@ -900,9 +904,6 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 		}
 		return ErrorResult<PendingQueryResult>(std::move(error), query);
 	}
-	// start the profiler
-	auto &profiler = QueryProfiler::Get(*this);
-	profiler.StartQuery(query, IsExplainAnalyze(statement ? statement.get() : prepared->unbound_statement.get()));
 
 	bool invalidate_query = true;
 	try {
@@ -1406,15 +1407,7 @@ unique_ptr<QueryResult> ClientContext::Execute(const shared_ptr<Relation> &relat
 	return ErrorResult<MaterializedQueryResult>(ErrorData(err_str));
 }
 
-SettingLookupResult ClientContext::TryGetCurrentSetting(const std::string &key, Value &result) const {
-	// first check the built-in settings
-	auto &db_config = DBConfig::GetConfig(*this);
-	auto option = db_config.GetOptionByName(key);
-	if (option && option->get_setting) {
-		result = option->get_setting(*this);
-		return SettingLookupResult(SettingScope::LOCAL);
-	}
-
+SettingLookupResult ClientContext::TryGetCurrentSettingInternal(const string &key, Value &result) const {
 	// check the client session values
 	const auto &session_config_map = config.set_variables;
 
@@ -1428,6 +1421,21 @@ SettingLookupResult ClientContext::TryGetCurrentSetting(const std::string &key,
 	return db->TryGetCurrentSetting(key, result);
 }
 
+SettingLookupResult ClientContext::TryGetCurrentSetting(const string &key, Value &result) const {
+	// first check the built-in settings
+	auto &db_config = DBConfig::GetConfig(*this);
+	auto option = db_config.GetOptionByName(key);
+	if (option) {
+		if (option->get_setting) {
+			result = option->get_setting(*this);
+			return SettingLookupResult(SettingScope::LOCAL);
+		}
+		// alias - search for the default key
+		return TryGetCurrentSettingInternal(option->name, result);
+	}
+	return TryGetCurrentSettingInternal(key, result);
+}
+
 ParserOptions ClientContext::GetParserOptions() const {
 	auto &client_config = ClientConfig::GetConfig(*this);
 	ParserOptions options;

package/src/duckdb/src/main/connection.cpp

@@ -19,7 +19,7 @@
 namespace duckdb {
 
 Connection::Connection(DatabaseInstance &database)
-    : context(make_shared_ptr<ClientContext>(database.shared_from_this())), warning_cb(nullptr) {
+    : context(make_shared_ptr<ClientContext>(database.shared_from_this())) {
 	auto &connection_manager = ConnectionManager::Get(database);
 	connection_manager.AddConnection(*context);
 	connection_manager.AssignConnectionId(*this);
@@ -31,18 +31,15 @@ Connection::Connection(DatabaseInstance &database)
 }
 
 Connection::Connection(DuckDB &database) : Connection(*database.instance) {
-	// Initialization of warning_cb happens in the other constructor
 }
 
-Connection::Connection(Connection &&other) noexcept : warning_cb(nullptr) {
+Connection::Connection(Connection &&other) noexcept {
 	std::swap(context, other.context);
-	std::swap(warning_cb, other.warning_cb);
 	std::swap(connection_id, other.connection_id);
 }
 
 Connection &Connection::operator=(Connection &&other) noexcept {
 	std::swap(context, other.context);
-	std::swap(warning_cb, other.warning_cb);
 	std::swap(connection_id, other.connection_id);
 	return *this;
 }

package/src/duckdb/src/main/database_file_path_manager.cpp

@@ -7,7 +7,7 @@ namespace duckdb {
 
 idx_t DatabaseFilePathManager::ApproxDatabaseCount() const {
 	lock_guard<mutex> path_lock(db_paths_lock);
-	return db_paths_to_name.size();
+	return db_paths.size();
 }
 
 InsertDatabasePathResult DatabaseFilePathManager::InsertDatabasePath(const string &path, const string &name,
@@ -18,14 +18,20 @@ InsertDatabasePathResult DatabaseFilePathManager::InsertDatabasePath(const strin
 	}
 
 	lock_guard<mutex> path_lock(db_paths_lock);
-	auto entry = db_paths_to_name.emplace(path, name);
+	auto entry = db_paths.emplace(path, DatabasePathInfo(name));
 	if (!entry.second) {
-		if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT && entry.first->second == name) {
-			return InsertDatabasePathResult::ALREADY_EXISTS;
+		auto &existing = entry.first->second;
+		if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT && existing.name == name) {
+			if (existing.is_attached) {
+				return InsertDatabasePathResult::ALREADY_EXISTS;
+			}
+			throw BinderException("Unique file handle conflict: Cannot attach \"%s\" - the database file \"%s\" is in "
+			                      "the process of being detached",
+			                      name, path);
 		}
 		throw BinderException("Unique file handle conflict: Cannot attach \"%s\" - the database file \"%s\" is already "
 		                      "attached by database \"%s\"",
-		                      name, path, entry.first->second);
+		                      name, path, existing.name);
 	}
 	options.stored_database_path = make_uniq<StoredDatabasePath>(*this, path, name);
 	return InsertDatabasePathResult::SUCCESS;
@@ -36,7 +42,18 @@ void DatabaseFilePathManager::EraseDatabasePath(const string &path) {
 		return;
 	}
 	lock_guard<mutex> path_lock(db_paths_lock);
-	db_paths_to_name.erase(path);
+	db_paths.erase(path);
+}
+
+void DatabaseFilePathManager::DetachDatabase(const string &path) {
+	if (path.empty() || path == IN_MEMORY_PATH) {
+		return;
+	}
+	lock_guard<mutex> path_lock(db_paths_lock);
+	auto entry = db_paths.find(path);
+	if (entry != db_paths.end()) {
+		entry->second.is_attached = false;
+	}
 }
 
 } // namespace duckdb

package/src/duckdb/src/main/database_manager.cpp

@@ -52,18 +52,33 @@ optional_ptr<AttachedDatabase> DatabaseManager::GetDatabase(ClientContext &conte
 		return database;
 	}
 	lock_guard<mutex> guard(databases_lock);
+	shared_ptr<AttachedDatabase> db;
 	if (StringUtil::Lower(name) == TEMP_CATALOG) {
-		return meta_transaction.UseDatabase(context.client_data->temporary_objects);
+		db = context.client_data->temporary_objects;
+	} else {
+		db = GetDatabaseInternal(guard, name);
 	}
+	if (!db) {
+		return nullptr;
+	}
+	return meta_transaction.UseDatabase(db);
+}
+
+shared_ptr<AttachedDatabase> DatabaseManager::GetDatabase(const string &name) {
+	lock_guard<mutex> guard(databases_lock);
+	return GetDatabaseInternal(guard, name);
+}
+
+shared_ptr<AttachedDatabase> DatabaseManager::GetDatabaseInternal(const lock_guard<mutex> &, const string &name) {
 	if (StringUtil::Lower(name) == SYSTEM_CATALOG) {
-		return meta_transaction.UseDatabase(system);
+		return system;
 	}
 	auto entry = databases.find(name);
 	if (entry == databases.end()) {
 		// not found
 		return nullptr;
 	}
-	return meta_transaction.UseDatabase(entry->second);
+	return entry->second;
 }
 
 shared_ptr<AttachedDatabase> DatabaseManager::AttachDatabase(ClientContext &context, AttachInfo &info,

package/src/duckdb/src/main/http/http_util.cpp

@@ -367,7 +367,9 @@ HTTPUtil::RunRequestWithRetry(const std::function<unique_ptr<HTTPResponse>(void)
 
 		try {
 			response = on_request();
-			response->url = request.url;
+			if (response) {
+				response->url = request.url;
+			}
 		} catch (IOException &e) {
 			exception_error = e.what();
 			caught_e = std::current_exception();

package/src/duckdb/src/main/relation/create_table_relation.cpp

@@ -29,6 +29,14 @@ BoundStatement CreateTableRelation::Bind(Binder &binder) {
 	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
+unique_ptr<QueryNode> CreateTableRelation::GetQueryNode() {
+	throw InternalException("Cannot create a query node from a create table relation");
+}
+
+string CreateTableRelation::GetQuery() {
+	return string();
+}
+
 const vector<ColumnDefinition> &CreateTableRelation::Columns() {
 	return columns;
 }

package/src/duckdb/src/main/relation/create_view_relation.cpp

@@ -35,6 +35,14 @@ BoundStatement CreateViewRelation::Bind(Binder &binder) {
 	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
+unique_ptr<QueryNode> CreateViewRelation::GetQueryNode() {
+	throw InternalException("Cannot create a query node from an update relation");
+}
+
+string CreateViewRelation::GetQuery() {
+	return string();
+}
+
 const vector<ColumnDefinition> &CreateViewRelation::Columns() {
 	return columns;
 }

package/src/duckdb/src/main/relation/delete_relation.cpp

@@ -26,6 +26,14 @@ BoundStatement DeleteRelation::Bind(Binder &binder) {
 	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
+unique_ptr<QueryNode> DeleteRelation::GetQueryNode() {
+	throw InternalException("Cannot create a query node from a delete relation");
+}
+
+string DeleteRelation::GetQuery() {
+	return string();
+}
+
 const vector<ColumnDefinition> &DeleteRelation::Columns() {
 	return columns;
 }

package/src/duckdb/src/main/relation/explain_relation.cpp

@@ -20,6 +20,14 @@ BoundStatement ExplainRelation::Bind(Binder &binder) {
 	return binder.Bind(explain.Cast<SQLStatement>());
 }
 
+unique_ptr<QueryNode> ExplainRelation::GetQueryNode() {
+	throw InternalException("Cannot create a query node from an explain relation");
+}
+
+string ExplainRelation::GetQuery() {
+	return string();
+}
+
 const vector<ColumnDefinition> &ExplainRelation::Columns() {
 	return columns;
 }