duckdb 0.10.2-dev0.0 → 0.10.2-dev3.0

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

@@ -25,10 +25,10 @@ class ParsedExpression;
 class QueryErrorContext;
 class TableRef;
 struct hugeint_t;
-class optional_idx;
+class optional_idx; // NOLINT: matching std style
 
-inline void assert_restrict_function(const void *left_start, const void *left_end, const void *right_start,
-                                     const void *right_end, const char *fname, int linenr) {
+inline void AssertRestrictFunction(const void *left_start, const void *left_end, const void *right_start,
+                                   const void *right_end, const char *fname, int linenr) {
 	// assert that the two pointers do not overlap
 #ifdef DEBUG
 	if (!(left_end <= right_start || right_end <= left_start)) {
@@ -39,13 +39,13 @@ inline void assert_restrict_function(const void *left_start, const void *left_en
 }
 
 #define ASSERT_RESTRICT(left_start, left_end, right_start, right_end)                                                  \
-	assert_restrict_function(left_start, left_end, right_start, right_end, __FILE__, __LINE__)
+	AssertRestrictFunction(left_start, left_end, right_start, right_end, __FILE__, __LINE__)
 
 //===--------------------------------------------------------------------===//
 // Exception Types
 //===--------------------------------------------------------------------===//
 
-enum class ExceptionType {
+enum class ExceptionType : uint8_t {
 	INVALID = 0,          // invalid type
 	OUT_OF_RANGE = 1,     // value out of range error
 	CONVERSION = 2,       // conversion/casting error
@@ -100,11 +100,12 @@ public:
 	DUCKDB_API static string ExceptionTypeToString(ExceptionType type);
 	DUCKDB_API static ExceptionType StringToExceptionType(const string &type);
 
-	template <typename... Args>
-	static string ConstructMessage(const string &msg, Args... params) {
-		const std::size_t num_args = sizeof...(Args);
-		if (num_args == 0)
+	template <typename... ARGS>
+	static string ConstructMessage(const string &msg, ARGS... params) {
+		const std::size_t num_args = sizeof...(ARGS);
+		if (num_args == 0) {
 			return msg;
+		}
 		std::vector<ExceptionFormatValue> values;
 		return ConstructMessageRecursive(msg, values, params...);
 	}
@@ -126,9 +127,9 @@ public:
 
 	DUCKDB_API static string ConstructMessageRecursive(const string &msg, std::vector<ExceptionFormatValue> &values);
 
-	template <class T, typename... Args>
+	template <class T, typename... ARGS>
 	static string ConstructMessageRecursive(const string &msg, std::vector<ExceptionFormatValue> &values, T param,
-	                                        Args... params) {
+	                                        ARGS... params) {
 		values.push_back(ExceptionFormatValue::CreateFormatValue<T>(param));
 		return ConstructMessageRecursive(msg, values, params...);
 	}
@@ -136,7 +137,7 @@ public:
 	DUCKDB_API static bool UncaughtException();
 
 	DUCKDB_API static string GetStackTrace(int max_depth = 120);
-	static string FormatStackTrace(string message = "") {
+	static string FormatStackTrace(const string &message = "") {
 		return (message + "\n" + GetStackTrace());
 	}
 
@@ -150,8 +151,8 @@ class ConnectionException : public Exception {
 public:
 	DUCKDB_API explicit ConnectionException(const string &msg);
 
-	template <typename... Args>
-	explicit ConnectionException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit ConnectionException(const string &msg, ARGS... params)
 	    : ConnectionException(ConstructMessage(msg, params...)) {
 	}
 };
@@ -160,8 +161,8 @@ class PermissionException : public Exception {
 public:
 	DUCKDB_API explicit PermissionException(const string &msg);
 
-	template <typename... Args>
-	explicit PermissionException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit PermissionException(const string &msg, ARGS... params)
 	    : PermissionException(ConstructMessage(msg, params...)) {
 	}
 };
@@ -170,22 +171,22 @@ class OutOfRangeException : public Exception {
 public:
 	DUCKDB_API explicit OutOfRangeException(const string &msg);
 
-	template <typename... Args>
-	explicit OutOfRangeException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit OutOfRangeException(const string &msg, ARGS... params)
 	    : OutOfRangeException(ConstructMessage(msg, params...)) {
 	}
-	DUCKDB_API OutOfRangeException(const int64_t value, const PhysicalType origType, const PhysicalType newType);
-	DUCKDB_API OutOfRangeException(const hugeint_t value, const PhysicalType origType, const PhysicalType newType);
-	DUCKDB_API OutOfRangeException(const double value, const PhysicalType origType, const PhysicalType newType);
-	DUCKDB_API OutOfRangeException(const PhysicalType varType, const idx_t length);
+	DUCKDB_API OutOfRangeException(const int64_t value, const PhysicalType orig_type, const PhysicalType new_type);
+	DUCKDB_API OutOfRangeException(const hugeint_t value, const PhysicalType orig_type, const PhysicalType new_type);
+	DUCKDB_API OutOfRangeException(const double value, const PhysicalType orig_type, const PhysicalType new_type);
+	DUCKDB_API OutOfRangeException(const PhysicalType var_type, const idx_t length);
 };
 
 class OutOfMemoryException : public Exception {
 public:
 	DUCKDB_API explicit OutOfMemoryException(const string &msg);
 
-	template <typename... Args>
-	explicit OutOfMemoryException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit OutOfMemoryException(const string &msg, ARGS... params)
 	    : OutOfMemoryException(ConstructMessage(msg, params...)) {
 	}
 };
@@ -194,8 +195,8 @@ class SyntaxException : public Exception {
 public:
 	DUCKDB_API explicit SyntaxException(const string &msg);
 
-	template <typename... Args>
-	explicit SyntaxException(const string &msg, Args... params) : SyntaxException(ConstructMessage(msg, params...)) {
+	template <typename... ARGS>
+	explicit SyntaxException(const string &msg, ARGS... params) : SyntaxException(ConstructMessage(msg, params...)) {
 	}
 };
 
@@ -203,8 +204,8 @@ class ConstraintException : public Exception {
 public:
 	DUCKDB_API explicit ConstraintException(const string &msg);
 
-	template <typename... Args>
-	explicit ConstraintException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit ConstraintException(const string &msg, ARGS... params)
 	    : ConstraintException(ConstructMessage(msg, params...)) {
 	}
 };
@@ -213,8 +214,8 @@ class DependencyException : public Exception {
 public:
 	DUCKDB_API explicit DependencyException(const string &msg);
 
-	template <typename... Args>
-	explicit DependencyException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit DependencyException(const string &msg, ARGS... params)
 	    : DependencyException(ConstructMessage(msg, params...)) {
 	}
 };
@@ -226,12 +227,12 @@ public:
 	explicit IOException(ExceptionType exception_type, const string &msg) : Exception(exception_type, msg) {
 	}
 
-	template <typename... Args>
-	explicit IOException(const string &msg, Args... params) : IOException(ConstructMessage(msg, params...)) {
+	template <typename... ARGS>
+	explicit IOException(const string &msg, ARGS... params) : IOException(ConstructMessage(msg, params...)) {
 	}
 
-	template <typename... Args>
-	explicit IOException(const string &msg, const unordered_map<string, string> &extra_info, Args... params)
+	template <typename... ARGS>
+	explicit IOException(const string &msg, const unordered_map<string, string> &extra_info, ARGS... params)
 	    : IOException(ConstructMessage(msg, params...), extra_info) {
 	}
 };
@@ -240,8 +241,8 @@ class MissingExtensionException : public Exception {
 public:
 	DUCKDB_API explicit MissingExtensionException(const string &msg);
 
-	template <typename... Args>
-	explicit MissingExtensionException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit MissingExtensionException(const string &msg, ARGS... params)
 	    : MissingExtensionException(ConstructMessage(msg, params...)) {
 	}
 };
@@ -250,8 +251,8 @@ class NotImplementedException : public Exception {
 public:
 	DUCKDB_API explicit NotImplementedException(const string &msg);
 
-	template <typename... Args>
-	explicit NotImplementedException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit NotImplementedException(const string &msg, ARGS... params)
 	    : NotImplementedException(ConstructMessage(msg, params...)) {
 	}
 };
@@ -265,8 +266,8 @@ class SerializationException : public Exception {
 public:
 	DUCKDB_API explicit SerializationException(const string &msg);
 
-	template <typename... Args>
-	explicit SerializationException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit SerializationException(const string &msg, ARGS... params)
 	    : SerializationException(ConstructMessage(msg, params...)) {
 	}
 };
@@ -275,8 +276,8 @@ class SequenceException : public Exception {
 public:
 	DUCKDB_API explicit SequenceException(const string &msg);
 
-	template <typename... Args>
-	explicit SequenceException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit SequenceException(const string &msg, ARGS... params)
 	    : SequenceException(ConstructMessage(msg, params...)) {
 	}
 };
@@ -290,14 +291,14 @@ class FatalException : public Exception {
 public:
 	explicit FatalException(const string &msg) : FatalException(ExceptionType::FATAL, msg) {
 	}
-	template <typename... Args>
-	explicit FatalException(const string &msg, Args... params) : FatalException(ConstructMessage(msg, params...)) {
+	template <typename... ARGS>
+	explicit FatalException(const string &msg, ARGS... params) : FatalException(ConstructMessage(msg, params...)) {
 	}
 
 protected:
 	DUCKDB_API explicit FatalException(ExceptionType type, const string &msg);
-	template <typename... Args>
-	explicit FatalException(ExceptionType type, const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit FatalException(ExceptionType type, const string &msg, ARGS... params)
 	    : FatalException(type, ConstructMessage(msg, params...)) {
 	}
 };
@@ -306,8 +307,8 @@ class InternalException : public Exception {
 public:
 	DUCKDB_API explicit InternalException(const string &msg);
 
-	template <typename... Args>
-	explicit InternalException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit InternalException(const string &msg, ARGS... params)
 	    : InternalException(ConstructMessage(msg, params...)) {
 	}
 };
@@ -317,12 +318,12 @@ public:
 	DUCKDB_API explicit InvalidInputException(const string &msg);
 	DUCKDB_API explicit InvalidInputException(const string &msg, const unordered_map<string, string> &extra_info);
 
-	template <typename... Args>
-	explicit InvalidInputException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit InvalidInputException(const string &msg, ARGS... params)
 	    : InvalidInputException(ConstructMessage(msg, params...)) {
 	}
-	template <typename... Args>
-	explicit InvalidInputException(Expression &expr, const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit InvalidInputException(Expression &expr, const string &msg, ARGS... params)
 	    : InvalidInputException(ConstructMessage(msg, params...), Exception::InitializeExtraInfo(expr)) {
 	}
 };
@@ -331,8 +332,7 @@ class InvalidTypeException : public Exception {
 public:
 	DUCKDB_API InvalidTypeException(PhysicalType type, const string &msg);
 	DUCKDB_API InvalidTypeException(const LogicalType &type, const string &msg);
-	DUCKDB_API
-	InvalidTypeException(const string &msg); //! Needed to be able to recreate the exception after it's been serialized
+	DUCKDB_API explicit InvalidTypeException(const string &msg);
 };
 
 class TypeMismatchException : public Exception {
@@ -341,16 +341,15 @@ public:
 	DUCKDB_API TypeMismatchException(const LogicalType &type_1, const LogicalType &type_2, const string &msg);
 	DUCKDB_API TypeMismatchException(optional_idx error_location, const LogicalType &type_1, const LogicalType &type_2,
 	                                 const string &msg);
-	DUCKDB_API
-	TypeMismatchException(const string &msg); //! Needed to be able to recreate the exception after it's been serialized
+	DUCKDB_API explicit TypeMismatchException(const string &msg);
 };
 
 class ParameterNotAllowedException : public Exception {
 public:
 	DUCKDB_API explicit ParameterNotAllowedException(const string &msg);
 
-	template <typename... Args>
-	explicit ParameterNotAllowedException(const string &msg, Args... params)
+	template <typename... ARGS>
+	explicit ParameterNotAllowedException(const string &msg, ARGS... params)
 	    : ParameterNotAllowedException(ConstructMessage(msg, params...)) {
 	}
 };

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

@@ -19,7 +19,7 @@ namespace duckdb {
 // Escaping " and quoting the value with "
 class SQLIdentifier {
 public:
-	SQLIdentifier(const string &raw_string) : raw_string(raw_string) {
+	explicit SQLIdentifier(const string &raw_string) : raw_string(raw_string) {
 	}
 
 public:
@@ -30,7 +30,7 @@ public:
 // Escaping ' and quoting the value with '
 class SQLString {
 public:
-	SQLString(const string &raw_string) : raw_string(raw_string) {
+	explicit SQLString(const string &raw_string) : raw_string(raw_string) {
 	}
 
 public:

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

@@ -50,7 +50,7 @@ public:
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 
@@ -219,7 +219,7 @@ private:
 };
 
 struct IntegerLiteralTypeInfo : public ExtraTypeInfo {
-	IntegerLiteralTypeInfo(Value constant_value);
+	explicit IntegerLiteralTypeInfo(Value constant_value);
 
 	Value constant_value;
 

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

@@ -0,0 +1,134 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/file_open_flags.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/enums/file_compression_type.hpp"
+
+namespace duckdb {
+
+enum class FileLockType : uint8_t { NO_LOCK = 0, READ_LOCK = 1, WRITE_LOCK = 2 };
+
+class FileOpenFlags {
+public:
+	static constexpr idx_t FILE_FLAGS_READ = idx_t(1 << 0);
+	static constexpr idx_t FILE_FLAGS_WRITE = idx_t(1 << 1);
+	static constexpr idx_t FILE_FLAGS_DIRECT_IO = idx_t(1 << 2);
+	static constexpr idx_t FILE_FLAGS_FILE_CREATE = idx_t(1 << 3);
+	static constexpr idx_t FILE_FLAGS_FILE_CREATE_NEW = idx_t(1 << 4);
+	static constexpr idx_t FILE_FLAGS_APPEND = idx_t(1 << 5);
+	static constexpr idx_t FILE_FLAGS_PRIVATE = idx_t(1 << 6);
+	static constexpr idx_t FILE_FLAGS_NULL_IF_NOT_EXISTS = idx_t(1 << 7);
+	static constexpr idx_t FILE_FLAGS_PARALLEL_ACCESS = idx_t(1 << 8);
+
+public:
+	FileOpenFlags() = default;
+	constexpr FileOpenFlags(idx_t flags) : flags(flags) { // NOLINT: allow implicit conversion
+	}
+	constexpr FileOpenFlags(FileLockType lock) : lock(lock) { // NOLINT: allow implicit conversion
+	}
+	constexpr FileOpenFlags(FileCompressionType compression) // NOLINT: allow implicit conversion
+	    : compression(compression) {
+	}
+	constexpr FileOpenFlags(idx_t flags, FileLockType lock, FileCompressionType compression)
+	    : flags(flags), lock(lock), compression(compression) {
+	}
+
+	static constexpr FileLockType MergeLock(FileLockType a, FileLockType b) {
+		return a == FileLockType::NO_LOCK ? b : a;
+	}
+
+	static constexpr FileCompressionType MergeCompression(FileCompressionType a, FileCompressionType b) {
+		return a == FileCompressionType::UNCOMPRESSED ? b : a;
+	}
+
+	inline constexpr FileOpenFlags operator|(FileOpenFlags b) const {
+		return FileOpenFlags(flags | b.flags, MergeLock(lock, b.lock), MergeCompression(compression, b.compression));
+	}
+	inline FileOpenFlags &operator|=(FileOpenFlags b) {
+		flags |= b.flags;
+		lock = MergeLock(lock, b.lock);
+		compression = MergeCompression(compression, b.compression);
+		return *this;
+	}
+
+	FileLockType Lock() {
+		return lock;
+	}
+
+	FileCompressionType Compression() {
+		return compression;
+	}
+
+	void SetCompression(FileCompressionType new_compression) {
+		compression = new_compression;
+	}
+
+	void Verify();
+
+	inline bool OpenForReading() const {
+		return flags & FILE_FLAGS_READ;
+	}
+	inline bool OpenForWriting() const {
+		return flags & FILE_FLAGS_WRITE;
+	}
+	inline bool DirectIO() const {
+		return flags & FILE_FLAGS_DIRECT_IO;
+	}
+	inline bool CreateFileIfNotExists() const {
+		return flags & FILE_FLAGS_FILE_CREATE;
+	}
+	inline bool OverwriteExistingFile() const {
+		return flags & FILE_FLAGS_FILE_CREATE_NEW;
+	}
+	inline bool OpenForAppending() const {
+		return flags & FILE_FLAGS_APPEND;
+	}
+	inline bool CreatePrivateFile() const {
+		return flags & FILE_FLAGS_PRIVATE;
+	}
+	inline bool ReturnNullIfNotExists() const {
+		return flags & FILE_FLAGS_NULL_IF_NOT_EXISTS;
+	}
+	inline bool RequireParallelAccess() const {
+		return flags & FILE_FLAGS_PARALLEL_ACCESS;
+	}
+
+private:
+	idx_t flags = 0;
+	FileLockType lock = FileLockType::NO_LOCK;
+	FileCompressionType compression = FileCompressionType::UNCOMPRESSED;
+};
+
+class FileFlags {
+public:
+	//! Open file with read access
+	static constexpr FileOpenFlags FILE_FLAGS_READ = FileOpenFlags(FileOpenFlags::FILE_FLAGS_READ);
+	//! Open file with write access
+	static constexpr FileOpenFlags FILE_FLAGS_WRITE = FileOpenFlags(FileOpenFlags::FILE_FLAGS_WRITE);
+	//! Use direct IO when reading/writing to the file
+	static constexpr FileOpenFlags FILE_FLAGS_DIRECT_IO = FileOpenFlags(FileOpenFlags::FILE_FLAGS_DIRECT_IO);
+	//! Create file if not exists, can only be used together with WRITE
+	static constexpr FileOpenFlags FILE_FLAGS_FILE_CREATE = FileOpenFlags(FileOpenFlags::FILE_FLAGS_FILE_CREATE);
+	//! Always create a new file. If a file exists, the file is truncated. Cannot be used together with CREATE.
+	static constexpr FileOpenFlags FILE_FLAGS_FILE_CREATE_NEW =
+	    FileOpenFlags(FileOpenFlags::FILE_FLAGS_FILE_CREATE_NEW);
+	//! Open file in append mode
+	static constexpr FileOpenFlags FILE_FLAGS_APPEND = FileOpenFlags(FileOpenFlags::FILE_FLAGS_APPEND);
+	//! Open file with restrictive permissions (600 on linux/mac) can only be used when creating, throws if file exists
+	static constexpr FileOpenFlags FILE_FLAGS_PRIVATE = FileOpenFlags(FileOpenFlags::FILE_FLAGS_PRIVATE);
+	//! Return NULL if the file does not exist instead of throwing an error
+	static constexpr FileOpenFlags FILE_FLAGS_NULL_IF_NOT_EXISTS =
+	    FileOpenFlags(FileOpenFlags::FILE_FLAGS_NULL_IF_NOT_EXISTS);
+	//! Multiple threads may perform reads and writes in parallel
+	static constexpr FileOpenFlags FILE_FLAGS_PARALLEL_ACCESS =
+	    FileOpenFlags(FileOpenFlags::FILE_FLAGS_PARALLEL_ACCESS);
+};
+
+} // namespace duckdb

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

@@ -30,12 +30,15 @@ public:
 
 	virtual SettingLookupResult TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info);
 	virtual SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) = 0;
-	virtual ClientContext *TryGetClientContext() = 0;
-
-	DUCKDB_API static ClientContext *TryGetClientContext(FileOpener *opener);
-	DUCKDB_API static SettingLookupResult TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result);
-	DUCKDB_API static SettingLookupResult TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result,
-	                                                           FileOpenerInfo &info);
+	virtual optional_ptr<ClientContext> TryGetClientContext() = 0;
+	virtual optional_ptr<DatabaseInstance> TryGetDatabase() = 0;
+
+	DUCKDB_API static optional_ptr<ClientContext> TryGetClientContext(optional_ptr<FileOpener> opener);
+	DUCKDB_API static optional_ptr<DatabaseInstance> TryGetDatabase(optional_ptr<FileOpener> opener);
+	DUCKDB_API static SettingLookupResult TryGetCurrentSetting(optional_ptr<FileOpener> opener, const string &key,
+	                                                           Value &result);
+	DUCKDB_API static SettingLookupResult TryGetCurrentSetting(optional_ptr<FileOpener> opener, const string &key,
+	                                                           Value &result, FileOpenerInfo &info);
 };
 
 } // namespace duckdb

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

@@ -16,6 +16,8 @@
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/enums/file_glob_options.hpp"
 #include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/common/error_data.hpp"
+#include "duckdb/common/file_open_flags.hpp"
 #include <functional>
 
 #undef CreateDirectory
@@ -64,6 +66,7 @@ public:
 	DUCKDB_API void Sync();
 	DUCKDB_API void Truncate(int64_t new_size);
 	DUCKDB_API string ReadLine();
+	DUCKDB_API bool Trim(idx_t offset_bytes, idx_t length_bytes);
 
 	DUCKDB_API bool CanSeek();
 	DUCKDB_API bool IsPipe();
@@ -85,7 +88,7 @@ public:
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 
@@ -94,41 +97,17 @@ public:
 	string path;
 };
 
-enum class FileLockType : uint8_t { NO_LOCK = 0, READ_LOCK = 1, WRITE_LOCK = 2 };
-
-class FileFlags {
-public:
-	//! Open file with read access
-	static constexpr uint8_t FILE_FLAGS_READ = 1 << 0;
-	//! Open file with write access
-	static constexpr uint8_t FILE_FLAGS_WRITE = 1 << 1;
-	//! Use direct IO when reading/writing to the file
-	static constexpr uint8_t FILE_FLAGS_DIRECT_IO = 1 << 2;
-	//! Create file if not exists, can only be used together with WRITE
-	static constexpr uint8_t FILE_FLAGS_FILE_CREATE = 1 << 3;
-	//! Always create a new file. If a file exists, the file is truncated. Cannot be used together with CREATE.
-	static constexpr uint8_t FILE_FLAGS_FILE_CREATE_NEW = 1 << 4;
-	//! Open file in append mode
-	static constexpr uint8_t FILE_FLAGS_APPEND = 1 << 5;
-	//! Open file with restrictive permissions (600 on linux/mac) can only be used when creating, throws if file exists
-	static constexpr uint8_t FILE_FLAGS_PRIVATE = 1 << 6;
-};
-
 class FileSystem {
 public:
 	DUCKDB_API virtual ~FileSystem();
 
 public:
-	DUCKDB_API static constexpr FileLockType DEFAULT_LOCK = FileLockType::NO_LOCK;
-	DUCKDB_API static constexpr FileCompressionType DEFAULT_COMPRESSION = FileCompressionType::UNCOMPRESSED;
 	DUCKDB_API static FileSystem &GetFileSystem(ClientContext &context);
 	DUCKDB_API static FileSystem &GetFileSystem(DatabaseInstance &db);
 	DUCKDB_API static FileSystem &Get(AttachedDatabase &db);
 
-	DUCKDB_API virtual unique_ptr<FileHandle> OpenFile(const string &path, uint8_t flags,
-	                                                   FileLockType lock = DEFAULT_LOCK,
-	                                                   FileCompressionType compression = DEFAULT_COMPRESSION,
-	                                                   FileOpener *opener = nullptr);
+	DUCKDB_API virtual unique_ptr<FileHandle> OpenFile(const string &path, FileOpenFlags flags,
+	                                                   optional_ptr<FileOpener> opener = nullptr);
 
 	//! Read exactly nr_bytes from the specified location in the file. Fails if nr_bytes could not be read. This is
 	//! equivalent to calling SetFilePointer(location) followed by calling Read().
@@ -141,23 +120,27 @@ public:
 	DUCKDB_API virtual int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes);
 	//! 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);
+	//! Excise a range of the file. The OS can drop pages from the page-cache, and the file-system is free to deallocate
+	//! this range (sparse file support). Reads to the range will succeed but will return undefined data.
+	DUCKDB_API virtual bool Trim(FileHandle &handle, idx_t offset_bytes, idx_t length_bytes);
 
 	//! 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
 	DUCKDB_API virtual time_t GetLastModifiedTime(FileHandle &handle);
-	//! Returns the file last modified time of a file handle, returns timespec with zero on all attributes on error
+	//! Returns the file type of the attached handle
 	DUCKDB_API virtual FileType GetFileType(FileHandle &handle);
 	//! Truncate a file to a maximum size of new_size, new_size should be smaller than or equal to the current size of
 	//! the file
 	DUCKDB_API virtual void Truncate(FileHandle &handle, int64_t new_size);
 
 	//! Check if a directory exists
-	DUCKDB_API virtual bool DirectoryExists(const string &directory);
+	DUCKDB_API virtual bool DirectoryExists(const string &directory, optional_ptr<FileOpener> opener = nullptr);
 	//! Create a directory if it does not exist
-	DUCKDB_API virtual void CreateDirectory(const string &directory);
+	DUCKDB_API virtual void CreateDirectory(const string &directory, optional_ptr<FileOpener> opener = nullptr);
 	//! Recursively remove a directory and all files in it
-	DUCKDB_API virtual void RemoveDirectory(const string &directory);
+	DUCKDB_API virtual void RemoveDirectory(const string &directory, optional_ptr<FileOpener> opener = nullptr);
+
 	//! List files in a directory, invoking the callback method for each one with (filename, is_dir)
 	DUCKDB_API virtual bool ListFiles(const string &directory,
 	                                  const std::function<void(const string &, bool)> &callback,
@@ -165,13 +148,14 @@ public:
 
 	//! Move a file from source path to the target, StorageManager relies on this being an atomic action for ACID
 	//! properties
-	DUCKDB_API virtual void MoveFile(const string &source, const string &target);
+	DUCKDB_API virtual void MoveFile(const string &source, const string &target,
+	                                 optional_ptr<FileOpener> opener = nullptr);
 	//! Check if a file exists
-	DUCKDB_API virtual bool FileExists(const string &filename);
+	DUCKDB_API virtual bool FileExists(const string &filename, optional_ptr<FileOpener> opener = nullptr);
 	//! Check if path is pipe
-	DUCKDB_API virtual bool IsPipe(const string &filename);
+	DUCKDB_API virtual bool IsPipe(const string &filename, optional_ptr<FileOpener> opener = nullptr);
 	//! Remove a file from disk
-	DUCKDB_API virtual void RemoveFile(const string &filename);
+	DUCKDB_API virtual void RemoveFile(const string &filename, optional_ptr<FileOpener> opener = nullptr);
 	//! Sync a file handle to disk
 	DUCKDB_API virtual void FileSync(FileHandle &handle);
 	//! Sets the working directory
@@ -187,7 +171,7 @@ public:
 	//! Expands a given path, including e.g. expanding the home directory of the user
 	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();
+	DUCKDB_API static optional_idx GetAvailableMemory();
 	//! Path separator for path
 	DUCKDB_API virtual string PathSeparator(const string &path);
 	//! Checks if path is starts with separator (i.e., '/' on UNIX '\\' on Windows)
@@ -233,6 +217,8 @@ public:
 	DUCKDB_API virtual void Reset(FileHandle &handle);
 	DUCKDB_API virtual idx_t SeekPosition(FileHandle &handle);
 
+	//! If FS was manually set by the user
+	DUCKDB_API virtual bool IsManuallySet();
 	//! Whether or not we can seek into the file
 	DUCKDB_API virtual bool CanSeek();
 	//! Whether or not the FS handles plain files on disk. This is relevant for certain optimizations, as random reads
@@ -251,6 +237,19 @@ public:
 	DUCKDB_API static bool IsRemoteFile(const string &path);
 
 	DUCKDB_API virtual void SetDisabledFileSystems(const vector<string> &names);
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<TARGET &>(*this);
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 } // namespace duckdb

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

@@ -20,9 +20,7 @@ class FilenamePattern {
 	friend Deserializer;
 
 public:
-	FilenamePattern() : _base("data_"), _pos(_base.length()), _uuid(false) {
-	}
-	~FilenamePattern() {
+	FilenamePattern() : base("data_"), pos(base.length()), uuid(false) {
 	}
 
 public:
@@ -33,9 +31,9 @@ public:
 	static FilenamePattern Deserialize(Deserializer &deserializer);
 
 private:
-	string _base;
-	idx_t _pos;
-	bool _uuid;
+	string base;
+	idx_t pos;
+	bool uuid;
 };
 
 } // namespace duckdb