duckdb 0.7.2-dev3353.0 → 0.7.2-dev3402.0

package/src/duckdb/src/function/cast/cast_function_set.cpp

@@ -1,8 +1,9 @@
 #include "duckdb/function/cast/cast_function_set.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/common/types/type_map.hpp"
+
 #include "duckdb/common/pair.hpp"
+#include "duckdb/common/types/type_map.hpp"
 #include "duckdb/function/cast_rules.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -65,19 +66,90 @@ struct MapCastNode {
 	int64_t implicit_cast_cost;
 };
 
+template <class MAP_VALUE_TYPE>
+static auto RelaxedTypeMatch(type_map_t<MAP_VALUE_TYPE> &map, const LogicalType &type) -> decltype(map.find(type)) {
+	D_ASSERT(map.find(type) == map.end()); // we shouldn't be here
+	switch (type.id()) {
+	case LogicalTypeId::LIST:
+		return map.find(LogicalType::LIST(LogicalType::ANY));
+	case LogicalTypeId::STRUCT:
+		return map.find(LogicalType::STRUCT({{"any", LogicalType::ANY}}));
+	case LogicalTypeId::MAP:
+		for (auto it = map.begin(); it != map.end(); it++) {
+			const auto &entry_type = it->first;
+			if (entry_type.id() != LogicalTypeId::MAP) {
+				continue;
+			}
+			auto &entry_key_type = MapType::KeyType(entry_type);
+			auto &entry_val_type = MapType::ValueType(entry_type);
+			if ((entry_key_type == LogicalType::ANY || entry_key_type == MapType::KeyType(type)) &&
+			    (entry_val_type == LogicalType::ANY || entry_val_type == MapType::ValueType(type))) {
+				return it;
+			}
+		}
+		return map.end();
+	case LogicalTypeId::UNION:
+		return map.find(LogicalType::UNION({{"any", LogicalType::ANY}}));
+	default:
+		return map.find(LogicalType::ANY);
+	}
+}
+
 struct MapCastInfo : public BindCastInfo {
-	type_map_t<type_map_t<MapCastNode>> casts;
+public:
+	const optional_ptr<MapCastNode> GetEntry(const LogicalType &source, const LogicalType &target) {
+		auto source_type_id_entry = casts.find(source.id());
+		if (source_type_id_entry == casts.end()) {
+			source_type_id_entry = casts.find(LogicalTypeId::ANY);
+			if (source_type_id_entry == casts.end()) {
+				return nullptr;
+			}
+		}
+
+		auto &source_type_entries = source_type_id_entry->second;
+		auto source_type_entry = source_type_entries.find(source);
+		if (source_type_entry == source_type_entries.end()) {
+			source_type_entry = RelaxedTypeMatch(source_type_entries, source);
+			if (source_type_entry == source_type_entries.end()) {
+				return nullptr;
+			}
+		}
+
+		auto &target_type_id_entries = source_type_entry->second;
+		auto target_type_id_entry = target_type_id_entries.find(target.id());
+		if (target_type_id_entry == target_type_id_entries.end()) {
+			target_type_id_entry = target_type_id_entries.find(LogicalTypeId::ANY);
+			if (target_type_id_entry == target_type_id_entries.end()) {
+				return nullptr;
+			}
+		}
+
+		auto &target_type_entries = target_type_id_entry->second;
+		auto target_type_entry = target_type_entries.find(target);
+		if (target_type_entry == target_type_entries.end()) {
+			target_type_entry = RelaxedTypeMatch(target_type_entries, target);
+			if (target_type_entry == target_type_entries.end()) {
+				return nullptr;
+			}
+		}
+
+		return &target_type_entry->second;
+	}
+
+	void AddEntry(const LogicalType &source, const LogicalType &target, MapCastNode node) {
+		casts[source.id()][source][target.id()].insert(make_pair(target, std::move(node)));
+	}
+
+private:
+	type_id_map_t<type_map_t<type_id_map_t<type_map_t<MapCastNode>>>> casts;
 };
 
 int64_t CastFunctionSet::ImplicitCastCost(const LogicalType &source, const LogicalType &target) {
 	// check if a cast has been registered
 	if (map_info) {
-		auto source_entry = map_info->casts.find(source);
-		if (source_entry != map_info->casts.end()) {
-			auto target_entry = source_entry->second.find(target);
-			if (target_entry != source_entry->second.end()) {
-				return target_entry->second.implicit_cast_cost;
-			}
+		auto entry = map_info->GetEntry(source, target);
+		if (entry) {
+			return entry->implicit_cast_cost;
 		}
 	}
 	// if not, fallback to the default implicit cast rules
@@ -87,22 +159,14 @@ int64_t CastFunctionSet::ImplicitCastCost(const LogicalType &source, const Logic
 BoundCastInfo MapCastFunction(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	D_ASSERT(input.info);
 	auto &map_info = (MapCastInfo &)*input.info;
-	auto &casts = map_info.casts;
-
-	auto entry = casts.find(source);
-	if (entry == casts.end()) {
-		// source type not found
-		return nullptr;
-	}
-	auto target_entry = entry->second.find(target);
-	if (target_entry == entry->second.end()) {
-		// target type not found
-		return nullptr;
-	}
-	if (target_entry->second.bind_function) {
-		return target_entry->second.bind_function(input, source, target);
+	auto entry = map_info.GetEntry(source, target);
+	if (entry) {
+		if (entry->bind_function) {
+			return entry->bind_function(input, source, target);
+		}
+		return entry->cast_info.Copy();
 	}
-	return target_entry->second.cast_info.Copy();
+	return nullptr;
 }
 
 void CastFunctionSet::RegisterCastFunction(const LogicalType &source, const LogicalType &target, BoundCastInfo function,
@@ -122,7 +186,7 @@ void CastFunctionSet::RegisterCastFunction(const LogicalType &source, const Logi
 		map_info = info.get();
 		bind_functions.emplace_back(MapCastFunction, std::move(info));
 	}
-	map_info->casts[source].insert(make_pair(target, std::move(node)));
+	map_info->AddEntry(source, target, std::move(node));
 }
 
 } // namespace duckdb

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

@@ -22,20 +22,26 @@ string PragmaShowTables(ClientContext &context, const FunctionParameters &parame
 	auto schema = ClientData::Get(context).catalog_search_path->GetDefault().schema;
 	schema = (schema == INVALID_SCHEMA) ? DEFAULT_SCHEMA : schema; // NOLINT
 
-	auto where_clause =
-	    StringUtil::Join({"where database_name = '", catalog, "' and schema_name = '", schema, "'"}, "");
+	auto where_clause = StringUtil::Format("where ((database_name = '%s') and (schema_name = '%s'))", catalog, schema);
 	// clang-format off
-	auto pragma_query = StringUtil::Join(
-	    {"with tables as (", 
-						"	SELECT table_name as name FROM duckdb_tables ", where_clause, 
-			 "), views as (",
-						"	SELECT view_name as name FROM duckdb_views ", where_clause, 
-			 "), indexes as (",
-						"	SELECT index_name as name FROM duckdb_indexes ", where_clause, 
-			 "), db_objects as (",
-						"	SELECT name FROM tables UNION ALL SELECT name FROM views UNION ALL SELECT name FROM indexes",
-	     ") SELECT name FROM db_objects ORDER BY name;"
-			}, "");
+	auto pragma_query = StringUtil::Format(R"EOF(
+	with "tables" as
+	(
+		SELECT table_name as "name"
+		FROM duckdb_tables %s
+	), "views" as
+	(
+		SELECT view_name as "name"
+		FROM duckdb_views %s
+	), db_objects as
+	(
+		SELECT "name" FROM "tables"
+		UNION ALL
+		SELECT "name" FROM "views"
+	)
+	SELECT "name"
+	FROM db_objects
+	ORDER BY "name";)EOF", where_clause, where_clause, where_clause);
 	// clang-format on
 
 	return pragma_query;
@@ -124,7 +130,6 @@ string PragmaImportDatabase(ClientContext &context, const FunctionParameters &pa
 		throw PermissionException("Import is disabled through configuration");
 	}
 	auto &fs = FileSystem::GetFileSystem(context);
-	auto *opener = FileSystem::GetFileOpener(context);
 
 	string final_query;
 	// read the "shema.sql" and "load.sql" files
@@ -132,7 +137,7 @@ string PragmaImportDatabase(ClientContext &context, const FunctionParameters &pa
 	for (auto &file : files) {
 		auto file_path = fs.JoinPath(parameters.values[0].ToString(), file);
 		auto handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK,
-		                          FileSystem::DEFAULT_COMPRESSION, opener);
+		                          FileSystem::DEFAULT_COMPRESSION);
 		auto fsize = fs.GetFileSize(*handle);
 		auto buffer = unique_ptr<char[]>(new char[fsize]);
 		fs.Read(*handle, buffer.get(), fsize);

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

@@ -254,10 +254,9 @@ struct LocalWriteCSVData : public LocalFunctionData {
 };
 
 struct GlobalWriteCSVData : public GlobalFunctionData {
-	GlobalWriteCSVData(FileSystem &fs, const string &file_path, FileOpener *opener, FileCompressionType compression)
-	    : fs(fs) {
+	GlobalWriteCSVData(FileSystem &fs, const string &file_path, FileCompressionType compression) : fs(fs) {
 		handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW,
-		                     FileLockType::WRITE_LOCK, compression, opener);
+		                     FileLockType::WRITE_LOCK, compression);
 	}
 
 	void WriteData(const_data_ptr_t data, idx_t size) {
@@ -288,8 +287,8 @@ static unique_ptr<GlobalFunctionData> WriteCSVInitializeGlobal(ClientContext &co
                                                                const string &file_path) {
 	auto &csv_data = bind_data.Cast<WriteCSVData>();
 	auto &options = csv_data.options;
-	auto global_data = make_uniq<GlobalWriteCSVData>(FileSystem::GetFileSystem(context), file_path,
-	                                                 FileSystem::GetFileOpener(context), options.compression);
+	auto global_data =
+	    make_uniq<GlobalWriteCSVData>(FileSystem::GetFileSystem(context), file_path, options.compression);
 
 	if (options.header) {
 		BufferedSerializer serializer;

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

@@ -23,9 +23,7 @@ namespace duckdb {
 unique_ptr<CSVFileHandle> ReadCSV::OpenCSV(const string &file_path, FileCompressionType compression,
                                            ClientContext &context) {
 	auto &fs = FileSystem::GetFileSystem(context);
-	auto opener = FileSystem::GetFileOpener(context);
-	auto file_handle =
-	    fs.OpenFile(file_path.c_str(), FileFlags::FILE_FLAGS_READ, FileLockType::NO_LOCK, compression, opener);
+	auto file_handle = fs.OpenFile(file_path.c_str(), FileFlags::FILE_FLAGS_READ, FileLockType::NO_LOCK, compression);
 	if (file_handle->CanSeek()) {
 		file_handle->Reset();
 	}
@@ -600,6 +598,7 @@ bool LineInfo::CanItGetLine(idx_t file_idx, idx_t batch_idx) {
 	return false;
 }
 
+// Returns the 1-indexed line number
 idx_t LineInfo::GetLine(idx_t batch_idx, idx_t line_error, idx_t file_idx, idx_t cur_start, bool verify) {
 	unique_ptr<lock_guard<mutex>> parallel_lock;
 	if (!verify) {
@@ -607,7 +606,8 @@ idx_t LineInfo::GetLine(idx_t batch_idx, idx_t line_error, idx_t file_idx, idx_t
 	}
 	idx_t line_count = 0;
 	if (done) {
-		return first_line;
+		// line count is 0-indexed, but we want to return 1-indexed
+		return first_line + 1;
 	}
 	for (idx_t i = 0; i <= batch_idx; i++) {
 		if (lines_read.find(i) == lines_read.end() && i != batch_idx) {
@@ -622,7 +622,8 @@ idx_t LineInfo::GetLine(idx_t batch_idx, idx_t line_error, idx_t file_idx, idx_t
 	}
 	done = true;
 	first_line = line_count + line_error;
-	return first_line;
+	// line count is 0-indexed, but we want to return 1-indexed
+	return first_line + 1;
 }
 
 static unique_ptr<GlobalTableFunctionState> ParallelCSVInitGlobal(ClientContext &context,

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev3353"
+#define DUCKDB_VERSION "0.7.2-dev3402"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "ec0ca94cdf"
+#define DUCKDB_SOURCE_ID "6f543cb464"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -24,7 +24,6 @@ public:
 	virtual bool TryGetCurrentSetting(const string &key, Value &result) = 0;
 	virtual ClientContext *TryGetClientContext() = 0;
 
-	DUCKDB_API static FileOpener *Get(ClientContext &context);
 	DUCKDB_API static ClientContext *TryGetClientContext(FileOpener *opener);
 	DUCKDB_API static bool TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result);
 };

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

@@ -15,6 +15,7 @@
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/enums/file_glob_options.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 #include <functional>
 
 #undef CreateDirectory
@@ -109,7 +110,6 @@ public:
 	DUCKDB_API static FileSystem &GetFileSystem(ClientContext &context);
 	DUCKDB_API static FileSystem &GetFileSystem(DatabaseInstance &db);
 	DUCKDB_API static FileSystem &Get(AttachedDatabase &db);
-	DUCKDB_API static FileOpener *GetFileOpener(ClientContext &context);
 
 	DUCKDB_API virtual unique_ptr<FileHandle> OpenFile(const string &path, uint8_t flags,
 	                                                   FileLockType lock = DEFAULT_LOCK,
@@ -128,8 +128,6 @@ public:
 	//! Write nr_bytes from the buffer into the file, moving the file pointer forward by nr_bytes.
 	DUCKDB_API virtual int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes);
 
-	//! Returns the extension of the file, or empty string if no extension was found.
-	DUCKDB_API string GetFileExtension(FileHandle &handle);
 	//! Returns the file size of a file handle, returns -1 on error
 	DUCKDB_API virtual int64_t GetFileSize(FileHandle &handle);
 	//! Returns the file last modified time of a file handle, returns timespec with zero on all attributes on error
@@ -167,9 +165,13 @@ public:
 	//! Gets the working directory
 	DUCKDB_API static string GetWorkingDirectory();
 	//! Gets the users home directory
-	DUCKDB_API static string GetHomeDirectory(FileOpener *opener);
+	DUCKDB_API static string GetHomeDirectory(optional_ptr<FileOpener> opener);
+	//! Gets the users home directory
+	DUCKDB_API virtual string GetHomeDirectory();
+	//! Expands a given path, including e.g. expanding the home directory of the user
+	DUCKDB_API static string ExpandPath(const string &path, optional_ptr<FileOpener> opener);
 	//! Expands a given path, including e.g. expanding the home directory of the user
-	DUCKDB_API static string ExpandPath(const string &path, FileOpener *opener);
+	DUCKDB_API virtual string ExpandPath(const string &path);
 	//! Returns the system-available memory in bytes. Returns DConstants::INVALID_INDEX if the system function fails.
 	DUCKDB_API static idx_t GetAvailableMemory();
 	//! Path separator for the current file system
@@ -187,7 +189,6 @@ public:
 
 	//! Runs a glob on the file system, returning a list of matching files
 	DUCKDB_API virtual vector<string> Glob(const string &path, FileOpener *opener = nullptr);
-	DUCKDB_API virtual vector<string> Glob(const string &path, ClientContext &context);
 	DUCKDB_API vector<string> GlobFiles(const string &path, ClientContext &context,
 	                                    FileGlobOptions options = FileGlobOptions::DISALLOW_EMPTY);
 

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

@@ -0,0 +1,118 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/opener_file_system.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/file_system.hpp"
+
+namespace duckdb {
+
+// The OpenerFileSystem is wrapper for a file system that pushes an appropriate FileOpener into the various API calls
+class OpenerFileSystem : public FileSystem {
+public:
+	virtual FileSystem &GetFileSystem() const = 0;
+	virtual optional_ptr<FileOpener> GetOpener() const = 0;
+
+	unique_ptr<FileHandle> OpenFile(const string &path, uint8_t flags, FileLockType lock = FileLockType::NO_LOCK,
+	                                FileCompressionType compression = FileCompressionType::UNCOMPRESSED,
+	                                FileOpener *opener = nullptr) override {
+		if (opener) {
+			throw InternalException("OpenerFileSystem cannot take an opener - the opener is pushed automatically");
+		}
+		return GetFileSystem().OpenFile(path, flags, lock, compression, GetOpener().get());
+	}
+
+	void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override {
+		GetFileSystem().Read(handle, buffer, nr_bytes, location);
+	};
+
+	void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override {
+		GetFileSystem().Write(handle, buffer, nr_bytes, location);
+	}
+
+	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override {
+		return GetFileSystem().Read(handle, buffer, nr_bytes);
+	}
+
+	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override {
+		return GetFileSystem().Write(handle, buffer, nr_bytes);
+	}
+
+	int64_t GetFileSize(FileHandle &handle) override {
+		return GetFileSystem().GetFileSize(handle);
+	}
+	time_t GetLastModifiedTime(FileHandle &handle) override {
+		return GetFileSystem().GetLastModifiedTime(handle);
+	}
+	FileType GetFileType(FileHandle &handle) override {
+		return GetFileSystem().GetFileType(handle);
+	}
+
+	void Truncate(FileHandle &handle, int64_t new_size) override {
+		GetFileSystem().Truncate(handle, new_size);
+	}
+
+	void FileSync(FileHandle &handle) override {
+		GetFileSystem().FileSync(handle);
+	}
+
+	bool DirectoryExists(const string &directory) override {
+		return GetFileSystem().DirectoryExists(directory);
+	}
+	void CreateDirectory(const string &directory) override {
+		return GetFileSystem().CreateDirectory(directory);
+	}
+
+	void RemoveDirectory(const string &directory) override {
+		return GetFileSystem().RemoveDirectory(directory);
+	}
+
+	bool ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
+	               FileOpener *opener = nullptr) override {
+		if (opener) {
+			throw InternalException("OpenerFileSystem cannot take an opener - the opener is pushed automatically");
+		}
+		return GetFileSystem().ListFiles(directory, callback, GetOpener().get());
+	}
+
+	void MoveFile(const string &source, const string &target) override {
+		GetFileSystem().MoveFile(source, target);
+	}
+
+	string GetHomeDirectory() override {
+		return FileSystem::GetHomeDirectory(GetOpener());
+	}
+
+	string ExpandPath(const string &path) override {
+		return FileSystem::ExpandPath(path, GetOpener());
+	}
+
+	bool FileExists(const string &filename) override {
+		return GetFileSystem().FileExists(filename);
+	}
+
+	bool IsPipe(const string &filename) override {
+		return GetFileSystem().IsPipe(filename);
+	}
+	virtual void RemoveFile(const string &filename) override {
+		GetFileSystem().RemoveFile(filename);
+	}
+
+	virtual vector<string> Glob(const string &path, FileOpener *opener = nullptr) override {
+		if (opener) {
+			throw InternalException("OpenerFileSystem cannot take an opener - the opener is pushed automatically");
+		}
+		return GetFileSystem().Glob(path, GetOpener().get());
+	}
+
+	std::string GetName() const override {
+		return "OpenerFileSystem - " + GetFileSystem().GetName();
+	}
+};
+
+} // namespace duckdb

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

@@ -21,8 +21,7 @@ public:
 
 	//! Serializes to a buffer allocated by the serializer, will expand when
 	//! writing past the initial threshold
-	DUCKDB_API BufferedFileWriter(FileSystem &fs, const string &path, uint8_t open_flags = DEFAULT_OPEN_FLAGS,
-	                              FileOpener *opener = nullptr);
+	DUCKDB_API BufferedFileWriter(FileSystem &fs, const string &path, uint8_t open_flags = DEFAULT_OPEN_FLAGS);
 
 	FileSystem &fs;
 	string path;

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

@@ -8,9 +8,10 @@
 
 #pragma once
 
+#include "duckdb/common/types.hpp"
+#include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/unordered_set.hpp"
-#include "duckdb/common/types.hpp"
 
 namespace duckdb {
 
@@ -31,4 +32,21 @@ using type_map_t = unordered_map<LogicalType, T, LogicalTypeHashFunction, Logica
 
 using type_set_t = unordered_set<LogicalType, LogicalTypeHashFunction, LogicalTypeEquality>;
 
+struct LogicalTypeIdHashFunction {
+	uint64_t operator()(const LogicalTypeId &type_id) const {
+		return duckdb::Hash<uint8_t>((uint8_t)type_id);
+	}
+};
+
+struct LogicalTypeIdEquality {
+	bool operator()(const LogicalTypeId &a, const LogicalTypeId &b) const {
+		return a == b;
+	}
+};
+
+template <typename T>
+using type_id_map_t = unordered_map<LogicalTypeId, T, LogicalTypeIdHashFunction, LogicalTypeIdEquality>;
+
+using type_id_set_t = unordered_set<LogicalTypeId, LogicalTypeIdHashFunction, LogicalTypeIdEquality>;
+
 } // namespace duckdb

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

@@ -42,7 +42,6 @@ public:
 	ClientContext &context;
 	FileSystem &fs;
 	Allocator &allocator;
-	FileOpener *opener;
 	BufferedCSVReaderOptions options;
 	vector<LogicalType> return_types;
 	vector<string> names;
@@ -76,8 +75,10 @@ public:
 	const vector<LogicalType> &GetTypes() {
 		return return_types;
 	}
+
+	//! Get the 1-indexed global line number for the given local error line
 	virtual idx_t GetLineError(idx_t line_error, idx_t buffer_idx) {
-		return line_error;
+		return line_error + 1;
 	};
 
 	//! Initialize projection indices to select all columns

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

@@ -17,6 +17,7 @@ public:
 	      tuple_end(tuple_end_p) {};
 	bool CanItGetLine(idx_t file_idx, idx_t batch_idx);
 
+	//! Return the 1-indexed line number
 	idx_t GetLine(idx_t batch_idx, idx_t line_error = 0, idx_t file_idx = 0, idx_t cur_start = 0, bool verify = true);
 	//! Verify if the CSV File was read correctly from [0,batch_idx] batches.
 	void Verify(idx_t file_idx, idx_t batch_idx, idx_t cur_first_pos);

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

@@ -20,6 +20,7 @@ class BufferedFileWriter;
 class ClientContext;
 class CatalogSearchPath;
 class FileOpener;
+class FileSystem;
 class HTTPState;
 class QueryProfiler;
 class QueryProfilerHistory;
@@ -55,6 +56,9 @@ struct ClientData {
 	//! HTTP State in this query
 	unique_ptr<HTTPState> http_state;
 
+	//! The clients' file system wrapper
+	unique_ptr<FileSystem> client_file_system;
+
 	//! The file search path
 	string file_search_path;
 

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

@@ -43,10 +43,10 @@ public:
 	static void InstallExtension(ClientContext &context, const string &extension, bool force_install);
 	static void InstallExtension(DBConfig &config, FileSystem &fs, const string &extension, bool force_install);
 	static void LoadExternalExtension(ClientContext &context, const string &extension);
-	static void LoadExternalExtension(DatabaseInstance &db, FileOpener *opener, const string &extension);
+	static void LoadExternalExtension(DatabaseInstance &db, FileSystem &fs, const string &extension);
 
 	static string ExtensionDirectory(ClientContext &context);
-	static string ExtensionDirectory(DBConfig &config, FileSystem &fs, FileOpener *opener);
+	static string ExtensionDirectory(DBConfig &config, FileSystem &fs);
 
 	static idx_t DefaultExtensionCount();
 	static DefaultExtension GetDefaultExtension(idx_t index);
@@ -70,9 +70,9 @@ private:
 	                                     const string &local_path, const string &extension, bool force_install);
 	static const vector<string> PathComponents();
 	static bool AllowAutoInstall(const string &extension);
-	static ExtensionInitResult InitialLoad(DBConfig &config, FileOpener *opener, const string &extension);
-	static bool TryInitialLoad(DBConfig &config, FileOpener *opener, const string &extension,
-	                           ExtensionInitResult &result, string &error);
+	static ExtensionInitResult InitialLoad(DBConfig &config, FileSystem &fs, const string &extension);
+	static bool TryInitialLoad(DBConfig &config, FileSystem &fs, const string &extension, ExtensionInitResult &result,
+	                           string &error);
 	//! For tagged releases we use the tag, else we use the git commit hash
 	static const string GetVersionDirectoryName();
 	//! Version tags occur with and without 'v', tag in extension path is always with 'v'

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

@@ -233,10 +233,6 @@ Executor &ClientContext::GetExecutor() {
 	return *active_query->executor;
 }
 
-FileOpener *FileOpener::Get(ClientContext &context) {
-	return ClientData::Get(context).file_opener.get();
-}
-
 const string &ClientContext::GetCurrentQuery() {
 	D_ASSERT(active_query);
 	return active_query->query;

package/src/duckdb/src/main/client_data.cpp

@@ -11,9 +11,27 @@
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/main/query_profiler.hpp"
+#include "duckdb/common/opener_file_system.hpp"
 
 namespace duckdb {
 
+class ClientFileSystem : public OpenerFileSystem {
+public:
+	explicit ClientFileSystem(ClientContext &context_p) : context(context_p) {
+	}
+
+	FileSystem &GetFileSystem() const override {
+		auto &config = DBConfig::GetConfig(context);
+		return *config.file_system;
+	}
+	optional_ptr<FileOpener> GetOpener() const override {
+		return ClientData::Get(context).file_opener.get();
+	}
+
+private:
+	ClientContext &context;
+};
+
 ClientData::ClientData(ClientContext &context) : catalog_search_path(make_uniq<CatalogSearchPath>(context)) {
 	auto &db = DatabaseInstance::GetDatabase(context);
 	profiler = make_shared<QueryProfiler>(context);
@@ -22,6 +40,7 @@ ClientData::ClientData(ClientContext &context) : catalog_search_path(make_uniq<C
 	temporary_objects->oid = DatabaseManager::Get(db).ModifyCatalog();
 	random_engine = make_uniq<RandomEngine>();
 	file_opener = make_uniq<ClientContextFileOpener>(context);
+	client_file_system = make_uniq<ClientFileSystem>(context);
 	temporary_objects->Initialize();
 }
 ClientData::~ClientData() {

package/src/duckdb/src/main/database.cpp

@@ -230,7 +230,10 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 
 	if (!config.options.database_type.empty()) {
 		// if we are opening an extension database - load the extension
-		ExtensionHelper::LoadExternalExtension(*this, nullptr, config.options.database_type);
+		if (!config.file_system) {
+			throw InternalException("No file system!?");
+		}
+		ExtensionHelper::LoadExternalExtension(*this, *config.file_system, config.options.database_type);
 	}
 
 	if (!config.options.unrecognized_options.empty()) {