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

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

@@ -15,13 +15,13 @@
 namespace duckdb {
 
 template <typename T>
-struct fixed_size_map_iterator_t;
+struct fixed_size_map_iterator_t; // NOLINT: match stl case
 
 template <typename T>
-struct const_fixed_size_map_iterator_t;
+struct const_fixed_size_map_iterator_t; // NOLINT: match stl case
 
 template <typename T>
-class fixed_size_map_t {
+class fixed_size_map_t { // NOLINT: match stl case
 	friend struct fixed_size_map_iterator_t<T>;
 	friend struct const_fixed_size_map_iterator_t<T>;
 
@@ -34,18 +34,18 @@ public:
 		resize(capacity);
 	}
 
-	idx_t size() const {
+	idx_t size() const { // NOLINT: match stl case
 		return count;
 	}
 
-	void resize(idx_t capacity_p) {
+	void resize(idx_t capacity_p) { // NOLINT: match stl case
 		capacity = capacity_p;
 		occupied = ValidityMask(capacity);
 		values = make_unsafe_uniq_array<T>(capacity + 1);
 		clear();
 	}
 
-	void clear() {
+	void clear() { // NOLINT: match stl case
 		count = 0;
 		occupied.SetAllInvalid(capacity);
 	}
@@ -62,23 +62,23 @@ public:
 		return values[key];
 	}
 
-	fixed_size_map_iterator_t<T> begin() {
+	fixed_size_map_iterator_t<T> begin() { // NOLINT: match stl case
 		return fixed_size_map_iterator_t<T>(begin_internal(), *this);
 	}
 
-	const_fixed_size_map_iterator_t<T> begin() const {
+	const_fixed_size_map_iterator_t<T> begin() const { // NOLINT: match stl case
 		return const_fixed_size_map_iterator_t<T>(begin_internal(), *this);
 	}
 
-	fixed_size_map_iterator_t<T> end() {
+	fixed_size_map_iterator_t<T> end() { // NOLINT: match stl case
 		return fixed_size_map_iterator_t<T>(capacity, *this);
 	}
 
-	const_fixed_size_map_iterator_t<T> end() const {
+	const_fixed_size_map_iterator_t<T> end() const { // NOLINT: match stl case
 		return const_fixed_size_map_iterator_t<T>(capacity, *this);
 	}
 
-	fixed_size_map_iterator_t<T> find(const idx_t &index) {
+	fixed_size_map_iterator_t<T> find(const idx_t &index) { // NOLINT: match stl case
 		if (occupied.RowIsValid(index)) {
 			return fixed_size_map_iterator_t<T>(index, *this);
 		} else {
@@ -86,7 +86,7 @@ public:
 		}
 	}
 
-	const_fixed_size_map_iterator_t<T> find(const idx_t &index) const {
+	const_fixed_size_map_iterator_t<T> find(const idx_t &index) const { // NOLINT: match stl case
 		if (occupied.RowIsValid(index)) {
 			return const_fixed_size_map_iterator_t<T>(index, *this);
 		} else {
@@ -95,7 +95,7 @@ public:
 	}
 
 private:
-	idx_t begin_internal() const {
+	idx_t begin_internal() const { // NOLINT: match stl case
 		idx_t index;
 		for (index = 0; index < capacity; index++) {
 			if (occupied.RowIsValid(index)) {

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

@@ -39,68 +39,62 @@ namespace duckdb {
 
 template <class... T>
 struct AlwaysFalse {
-	static constexpr bool value = false;
+	static constexpr bool VALUE = false;
 };
 
 template<typename T>
 using reference = std::reference_wrapper<T>;
 
-template<class _Tp, bool SAFE = true>
-struct __unique_if
+template<class DATA_TYPE, bool SAFE = true>
+struct TemplatedUniqueIf
 {
-    typedef unique_ptr<_Tp, std::default_delete<_Tp>, SAFE> __unique_single;
+    typedef unique_ptr<DATA_TYPE, std::default_delete<DATA_TYPE>, SAFE> templated_unique_single_t;
 };
 
-template<class _Tp>
-struct __unique_if<_Tp[]>
+template<class DATA_TYPE, size_t N>
+struct TemplatedUniqueIf<DATA_TYPE[N]>
 {
-    typedef unique_ptr<_Tp[]> __unique_array_unknown_bound;
+    typedef void TemplatedUniqueArrayKnownBound; // NOLINT: mimic std style
 };
 
-template<class _Tp, size_t _Np>
-struct __unique_if<_Tp[_Np]>
-{
-    typedef void __unique_array_known_bound;
-};
-
-template<class _Tp, class... _Args>
+template<class DATA_TYPE, class... ARGS>
 inline 
-typename __unique_if<_Tp, true>::__unique_single
-make_uniq(_Args&&... __args)
+typename TemplatedUniqueIf<DATA_TYPE, true>::templated_unique_single_t
+make_uniq(ARGS&&... args) // NOLINT: mimic std style
 {
-    return unique_ptr<_Tp, std::default_delete<_Tp>, true>(new _Tp(std::forward<_Args>(__args)...));
+    return unique_ptr<DATA_TYPE, std::default_delete<DATA_TYPE>, true>(new DATA_TYPE(std::forward<ARGS>(args)...));
 }
 
-template<class _Tp, class... _Args>
+template<class DATA_TYPE, class... ARGS>
 inline 
-typename __unique_if<_Tp, false>::__unique_single
-make_unsafe_uniq(_Args&&... __args)
+typename TemplatedUniqueIf<DATA_TYPE, false>::templated_unique_single_t
+make_unsafe_uniq(ARGS&&... args) // NOLINT: mimic std style
 {
-    return unique_ptr<_Tp, std::default_delete<_Tp>, false>(new _Tp(std::forward<_Args>(__args)...));
+    return unique_ptr<DATA_TYPE, std::default_delete<DATA_TYPE>, false>(new DATA_TYPE(std::forward<ARGS>(args)...));
 }
 
-template<class _Tp>
-inline unique_ptr<_Tp[], std::default_delete<_Tp>, true>
-make_uniq_array(size_t __n)
+template<class DATA_TYPE>
+inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, true>
+make_uniq_array(size_t n) // NOLINT: mimic std style
 {
-    return unique_ptr<_Tp[], std::default_delete<_Tp>, true>(new _Tp[__n]());
+    return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, true>(new DATA_TYPE[n]());
 }
 
-template<class _Tp>
-inline unique_ptr<_Tp[], std::default_delete<_Tp>, false>
-make_unsafe_uniq_array(size_t __n)
+template<class DATA_TYPE>
+inline unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, false>
+make_unsafe_uniq_array(size_t n) // NOLINT: mimic std style
 {
-    return unique_ptr<_Tp[], std::default_delete<_Tp>, false>(new _Tp[__n]());
+    return unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE>, false>(new DATA_TYPE[n]());
 }
 
-template<class _Tp, class... _Args>
-    typename __unique_if<_Tp>::__unique_array_known_bound
-    make_uniq(_Args&&...) = delete;
+template<class DATA_TYPE, class... ARGS>
+    typename TemplatedUniqueIf<DATA_TYPE>::TemplatedUniqueArrayKnownBound
+    make_uniq(ARGS&&...) = delete; // NOLINT: mimic std style
 
 
-template <typename S, typename T, typename... Args>
-unique_ptr<S> make_uniq_base(Args &&... args) {
-	return unique_ptr<S>(new T(std::forward<Args>(args)...));
+template <typename S, typename T, typename... ARGS>
+unique_ptr<S> make_uniq_base(ARGS &&... args) { // NOLINT: mimic std style
+	return unique_ptr<S>(new T(std::forward<ARGS>(args)...));
 }
 
 #ifdef DUCKDB_ENABLE_DEPRECATED_API
@@ -111,7 +105,7 @@ unique_ptr<S> make_unique_base(Args &&... args) {
 #endif // DUCKDB_ENABLE_DEPRECATED_API
 
 template <typename T, typename S>
-unique_ptr<S> unique_ptr_cast(unique_ptr<T> src) {
+unique_ptr<S> unique_ptr_cast(unique_ptr<T> src) { // NOLINT: mimic std style
 	return unique_ptr<S>(static_cast<S *>(src.release()));
 }
 
@@ -137,12 +131,12 @@ typename std::remove_reference<T>::type&& move(T&& t) noexcept {
 }
 #endif
 
-template <class T, class... _Args>
-static duckdb::unique_ptr<T> make_unique(_Args&&... __args) {
+template <class T, class... ARGS>
+static duckdb::unique_ptr<T> make_unique(ARGS&&... __args) { // NOLINT: mimic std style
 #ifndef DUCKDB_ENABLE_DEPRECATED_API
 	static_assert(sizeof(T) == 0, "Use make_uniq instead of make_unique!");
 #endif // DUCKDB_ENABLE_DEPRECATED_API
-	return unique_ptr<T>(new T(std::forward<_Args>(__args)...));
+	return unique_ptr<T>(new T(std::forward<ARGS>(__args)...));
 }
 
 template <typename T>
@@ -184,13 +178,13 @@ T SignValue(T a) {
 template <typename T>
 const T Load(const_data_ptr_t ptr) {
 	T ret;
-	memcpy(&ret, ptr, sizeof(ret));
+	memcpy(&ret, ptr, sizeof(ret)); // NOLINT
 	return ret;
 }
 
 template <typename T>
 void Store(const T &val, data_ptr_t ptr) {
-	memcpy(ptr, (void *)&val, sizeof(val));
+	memcpy(ptr, (void *)&val, sizeof(val)); // NOLINT
 }
 
 //! This assigns a shared pointer, but ONLY assigns if "target" is not equal to "source"
@@ -211,19 +205,20 @@ using const_reference = std::reference_wrapper<const T>;
 
 //! Returns whether or not two reference wrappers refer to the same object
 template<class T>
-bool RefersToSameObject(const reference<T> &A, const reference<T> &B) {
-	return &A.get() == &B.get();
+bool RefersToSameObject(const reference<T> &a, const reference<T> &b) {
+	return &a.get() == &b.get();
 }
 
 template<class T>
-bool RefersToSameObject(const T &A, const T &B) {
-	return &A == &B;
+bool RefersToSameObject(const T &a, const T &b) {
+	return &a == &b;
 }
 
 template<class T, class SRC>
-void DynamicCastCheck(SRC *source) {
+void DynamicCastCheck(const SRC *source) {
 #ifndef __APPLE__
-	D_ASSERT(dynamic_cast<T *>(source));
+	// Actual check is on the fact that dynamic_cast and reinterpret_cast are equivalent
+	D_ASSERT(reinterpret_cast<const T *>(source) == dynamic_cast<const T *>(source));
 #endif
 }
 

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

@@ -84,7 +84,7 @@ public:
 	shared_ptr<CachedFile> &GetCachedFile(const string &path);
 	//! Helper functions to get the HTTP state
 	static shared_ptr<HTTPState> TryGetState(ClientContext &context, bool create_on_missing = true);
-	static shared_ptr<HTTPState> TryGetState(FileOpener *opener, bool create_on_missing = true);
+	static shared_ptr<HTTPState> TryGetState(optional_ptr<FileOpener> opener, bool create_on_missing = true);
 
 	bool IsEmpty() {
 		return head_count == 0 && get_count == 0 && put_count == 0 && post_count == 0 && total_bytes_received == 0 &&

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

@@ -8,9 +8,9 @@
 namespace duckdb {
 
 // Forward declaration to allow conversion between hugeint and uhugeint
-struct uhugeint_t;
+struct uhugeint_t; // NOLINT: use numeric casing
 
-struct hugeint_t {
+struct hugeint_t { // NOLINT: use numeric casing
 public:
 	uint64_t lower;
 	int64_t upper;

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

@@ -18,7 +18,7 @@ namespace duckdb {
 template <class T, class INDEX_TYPE>
 class IndexVector {
 public:
-	void push_back(T element) {
+	void push_back(T element) { // NOLINT: match stl API
 		internal_vector.push_back(std::move(element));
 	}
 
@@ -30,34 +30,34 @@ public:
 		return internal_vector[idx.index];
 	}
 
-	idx_t size() const {
+	idx_t size() const { // NOLINT: match stl API
 		return internal_vector.size();
 	}
 
-	bool empty() const {
+	bool empty() const { // NOLINT: match stl API
 		return internal_vector.empty();
 	}
 
-	void reserve(idx_t size) {
+	void reserve(idx_t size) { // NOLINT: match stl API
 		internal_vector.reserve(size);
 	}
 
-	typename vector<T>::iterator begin() {
+	typename vector<T>::iterator begin() { // NOLINT: match stl API
 		return internal_vector.begin();
 	}
-	typename vector<T>::iterator end() {
+	typename vector<T>::iterator end() { // NOLINT: match stl API
 		return internal_vector.end();
 	}
-	typename vector<T>::const_iterator cbegin() {
+	typename vector<T>::const_iterator cbegin() { // NOLINT: match stl API
 		return internal_vector.cbegin();
 	}
-	typename vector<T>::const_iterator cend() {
+	typename vector<T>::const_iterator cend() { // NOLINT: match stl API
 		return internal_vector.cend();
 	}
-	typename vector<T>::const_iterator begin() const {
+	typename vector<T>::const_iterator begin() const { // NOLINT: match stl API
 		return internal_vector.begin();
 	}
-	typename vector<T>::const_iterator end() const {
+	typename vector<T>::const_iterator end() const { // NOLINT: match stl API
 		return internal_vector.end();
 	}
 

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

@@ -15,9 +15,8 @@ namespace duckdb {
 
 class LocalFileSystem : public FileSystem {
 public:
-	unique_ptr<FileHandle> OpenFile(const string &path, uint8_t flags, FileLockType lock = FileLockType::NO_LOCK,
-	                                FileCompressionType compression = FileCompressionType::UNCOMPRESSED,
-	                                FileOpener *opener = nullptr) override;
+	unique_ptr<FileHandle> OpenFile(const string &path, FileOpenFlags flags,
+	                                optional_ptr<FileOpener> opener = nullptr) override;
 
 	//! 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().
@@ -30,6 +29,10 @@ public:
 	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
 	//! Write nr_bytes from the buffer into the file, moving the file pointer forward by nr_bytes.
 	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
+	//! Excise a range of the file. The file-system is free to deallocate this
+	//! range (sparse file support). Reads to the range will succeed but will return
+	//! undefined data.
+	bool Trim(FileHandle &handle, idx_t offset_bytes, idx_t length_bytes) override;
 
 	//! Returns the file size of a file handle, returns -1 on error
 	int64_t GetFileSize(FileHandle &handle) override;
@@ -42,24 +45,24 @@ public:
 	void Truncate(FileHandle &handle, int64_t new_size) override;
 
 	//! Check if a directory exists
-	bool DirectoryExists(const string &directory) override;
+	bool DirectoryExists(const string &directory, optional_ptr<FileOpener> opener = nullptr) override;
 	//! Create a directory if it does not exist
-	void CreateDirectory(const string &directory) override;
+	void CreateDirectory(const string &directory, optional_ptr<FileOpener> opener = nullptr) override;
 	//! Recursively remove a directory and all files in it
-	void RemoveDirectory(const string &directory) override;
+	void RemoveDirectory(const string &directory, optional_ptr<FileOpener> opener = nullptr) override;
 	//! List files in a directory, invoking the callback method for each one with (filename, is_dir)
 	bool ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
 	               FileOpener *opener = nullptr) override;
 	//! Move a file from source path to the target, StorageManager relies on this being an atomic action for ACID
 	//! properties
-	void MoveFile(const string &source, const string &target) override;
+	void MoveFile(const string &source, const string &target, optional_ptr<FileOpener> opener = nullptr) override;
 	//! Check if a file exists
-	bool FileExists(const string &filename) override;
+	bool FileExists(const string &filename, optional_ptr<FileOpener> opener = nullptr) override;
 
 	//! Check if path is a pipe
-	bool IsPipe(const string &filename) override;
+	bool IsPipe(const string &filename, optional_ptr<FileOpener> opener = nullptr) override;
 	//! Remove a file from disk
-	void RemoveFile(const string &filename) override;
+	void RemoveFile(const string &filename, optional_ptr<FileOpener> opener = nullptr) override;
 	//! Sync a file handle to disk
 	void FileSync(FileHandle &handle) override;
 

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

@@ -2,13 +2,13 @@
 
 namespace duckdb {
 
-template <bool ENABLED>
+template <bool IS_ENABLED>
 struct MemorySafety {
 #ifdef DEBUG
 	// In DEBUG mode safety is always on
-	static constexpr bool enabled = true;
+	static constexpr bool ENABLED = true;
 #else
-	static constexpr bool enabled = ENABLED;
+	static constexpr bool ENABLED = IS_ENABLED;
 #endif
 };
 

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

@@ -29,7 +29,7 @@ struct MultiFileReaderOptions {
 	DUCKDB_API void AddBatchInfo(BindInfo &bind_info) const;
 	DUCKDB_API void AutoDetectHivePartitioning(const vector<string> &files, ClientContext &context);
 	DUCKDB_API static bool AutoDetectHivePartitioningInternal(const vector<string> &files, ClientContext &context);
-	DUCKDB_API void AutoDetectHiveTypesInternal(const string &file, ClientContext &context);
+	DUCKDB_API void AutoDetectHiveTypesInternal(const vector<string> &file, ClientContext &context);
 	DUCKDB_API void VerifyHiveTypesArePartitions(const std::map<string, string> &partitions) const;
 	DUCKDB_API LogicalType GetHiveLogicalType(const string &hive_partition_column) const;
 	DUCKDB_API Value GetHivePartitionValue(const string &base, const string &entry, ClientContext &context) const;

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

@@ -18,13 +18,16 @@ 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 {
+	void VerifyNoOpener(optional_ptr<FileOpener> opener) {
 		if (opener) {
 			throw InternalException("OpenerFileSystem cannot take an opener - the opener is pushed automatically");
 		}
-		return GetFileSystem().OpenFile(path, flags, lock, compression, GetOpener().get());
+	}
+
+	unique_ptr<FileHandle> OpenFile(const string &path, FileOpenFlags flags,
+	                                optional_ptr<FileOpener> opener = nullptr) override {
+		VerifyNoOpener(opener);
+		return GetFileSystem().OpenFile(path, flags, GetOpener());
 	}
 
 	void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override {
@@ -61,27 +64,29 @@ public:
 		GetFileSystem().FileSync(handle);
 	}
 
-	bool DirectoryExists(const string &directory) override {
-		return GetFileSystem().DirectoryExists(directory);
+	bool DirectoryExists(const string &directory, optional_ptr<FileOpener> opener) override {
+		VerifyNoOpener(opener);
+		return GetFileSystem().DirectoryExists(directory, GetOpener());
 	}
-	void CreateDirectory(const string &directory) override {
-		return GetFileSystem().CreateDirectory(directory);
+	void CreateDirectory(const string &directory, optional_ptr<FileOpener> opener) override {
+		VerifyNoOpener(opener);
+		return GetFileSystem().CreateDirectory(directory, GetOpener());
 	}
 
-	void RemoveDirectory(const string &directory) override {
-		return GetFileSystem().RemoveDirectory(directory);
+	void RemoveDirectory(const string &directory, optional_ptr<FileOpener> opener) override {
+		VerifyNoOpener(opener);
+		return GetFileSystem().RemoveDirectory(directory, GetOpener());
 	}
 
 	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");
-		}
+		VerifyNoOpener(opener);
 		return GetFileSystem().ListFiles(directory, callback, GetOpener().get());
 	}
 
-	void MoveFile(const string &source, const string &target) override {
-		GetFileSystem().MoveFile(source, target);
+	void MoveFile(const string &source, const string &target, optional_ptr<FileOpener> opener) override {
+		VerifyNoOpener(opener);
+		GetFileSystem().MoveFile(source, target, GetOpener());
 	}
 
 	string GetHomeDirectory() override {
@@ -92,15 +97,18 @@ public:
 		return FileSystem::ExpandPath(path, GetOpener());
 	}
 
-	bool FileExists(const string &filename) override {
-		return GetFileSystem().FileExists(filename);
+	bool FileExists(const string &filename, optional_ptr<FileOpener> opener) override {
+		VerifyNoOpener(opener);
+		return GetFileSystem().FileExists(filename, GetOpener());
 	}
 
-	bool IsPipe(const string &filename) override {
-		return GetFileSystem().IsPipe(filename);
+	bool IsPipe(const string &filename, optional_ptr<FileOpener> opener) override {
+		VerifyNoOpener(opener);
+		return GetFileSystem().IsPipe(filename, GetOpener());
 	}
-	void RemoveFile(const string &filename) override {
-		GetFileSystem().RemoveFile(filename);
+	void RemoveFile(const string &filename, optional_ptr<FileOpener> opener) override {
+		VerifyNoOpener(opener);
+		GetFileSystem().RemoveFile(filename, GetOpener());
 	}
 
 	string PathSeparator(const string &path) override {
@@ -108,15 +116,33 @@ public:
 	}
 
 	vector<string> Glob(const string &path, FileOpener *opener = nullptr) override {
-		if (opener) {
-			throw InternalException("OpenerFileSystem cannot take an opener - the opener is pushed automatically");
-		}
+		VerifyNoOpener(opener);
 		return GetFileSystem().Glob(path, GetOpener().get());
 	}
 
 	std::string GetName() const override {
 		return "OpenerFileSystem - " + GetFileSystem().GetName();
 	}
+
+	void RegisterSubSystem(unique_ptr<FileSystem> sub_fs) override {
+		GetFileSystem().RegisterSubSystem(std::move(sub_fs));
+	}
+
+	void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs) override {
+		GetFileSystem().RegisterSubSystem(compression_type, std::move(fs));
+	}
+
+	void UnregisterSubSystem(const string &name) override {
+		GetFileSystem().UnregisterSubSystem(name);
+	}
+
+	void SetDisabledFileSystems(const vector<string> &names) override {
+		GetFileSystem().SetDisabledFileSystems(names);
+	}
+
+	vector<string> ListSubSystems() override {
+		return GetFileSystem().ListSubSystems();
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/operator/abs.hpp

@@ -39,7 +39,7 @@ inline int8_t TryAbsOperator::Operation(int8_t input) {
 	if (input == NumericLimits<int8_t>::Minimum()) {
 		throw OutOfRangeException("Overflow on abs(%d)", input);
 	}
-	return input < 0 ? -input : input;
+	return AbsOperator::Operation<int8_t, int8_t>(input);
 }
 
 template <>
@@ -47,7 +47,7 @@ inline int16_t TryAbsOperator::Operation(int16_t input) {
 	if (input == NumericLimits<int16_t>::Minimum()) {
 		throw OutOfRangeException("Overflow on abs(%d)", input);
 	}
-	return input < 0 ? -input : input;
+	return AbsOperator::Operation<int16_t, int16_t>(input);
 }
 
 template <>
@@ -55,7 +55,7 @@ inline int32_t TryAbsOperator::Operation(int32_t input) {
 	if (input == NumericLimits<int32_t>::Minimum()) {
 		throw OutOfRangeException("Overflow on abs(%d)", input);
 	}
-	return input < 0 ? -input : input;
+	return AbsOperator::Operation<int32_t, int32_t>(input);
 }
 
 template <>
@@ -63,7 +63,15 @@ inline int64_t TryAbsOperator::Operation(int64_t input) {
 	if (input == NumericLimits<int64_t>::Minimum()) {
 		throw OutOfRangeException("Overflow on abs(%d)", input);
 	}
-	return input < 0 ? -input : input;
+	return AbsOperator::Operation<int64_t, int64_t>(input);
+}
+
+template <>
+inline hugeint_t TryAbsOperator::Operation(hugeint_t input) {
+	if (input == NumericLimits<hugeint_t>::Minimum()) {
+		throw OutOfRangeException("Overflow on abs(%s)", input.ToString());
+	}
+	return AbsOperator::Operation<hugeint_t, hugeint_t>(input);
 }
 
 template <>

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

@@ -14,7 +14,7 @@
 namespace duckdb {
 
 template <class T>
-class optional_ptr {
+class optional_ptr { // NOLINT: mimic std casing
 public:
 	optional_ptr() : ptr(nullptr) {
 	}
@@ -29,7 +29,7 @@ public:
 		}
 	}
 
-	operator bool() const {
+	operator bool() const { // NOLINT: allow implicit conversion to bool
 		return ptr;
 	}
 	T &operator*() {
@@ -48,16 +48,16 @@ public:
 		CheckValid();
 		return ptr;
 	}
-	T *get() {
+	T *get() { // NOLINT: mimic std casing
 		// CheckValid();
 		return ptr;
 	}
-	const T *get() const {
+	const T *get() const { // NOLINT: mimic std casing
 		// CheckValid();
 		return ptr;
 	}
 	// this looks dirty - but this is the default behavior of raw pointers
-	T *get_mutable() const {
+	T *get_mutable() const { // NOLINT: mimic std casing
 		// CheckValid();
 		return ptr;
 	}

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

@@ -28,7 +28,7 @@ public:
 	bool CanSeek() override {
 		return false;
 	}
-	bool IsPipe(const string &filename) override {
+	bool IsPipe(const string &filename, optional_ptr<FileOpener> opener) override {
 		return true;
 	}
 	void FileSync(FileHandle &handle) override;

package/src/duckdb/src/include/duckdb/common/platform.h

@@ -3,7 +3,7 @@
 
 namespace duckdb {
 
-std::string DuckDBPlatform() {
+std::string DuckDBPlatform() { // NOLINT: allow definition in header
 #if defined(DUCKDB_CUSTOM_PLATFORM)
 	return DUCKDB_QUOTE_DEFINE(DUCKDB_CUSTOM_PLATFORM);
 #endif

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

@@ -23,14 +23,14 @@ public:
 	//! Print the object to stderr
 	DUCKDB_API static void Print(const string &str);
 	//! Print the formatted object to the stream
-	template <typename... Args>
-	static void PrintF(OutputStream stream, const string &str, Args... params) {
+	template <typename... ARGS>
+	static void PrintF(OutputStream stream, const string &str, ARGS... params) {
 		Printer::Print(stream, StringUtil::Format(str, params...));
 	}
 	//! Print the formatted object to stderr
-	template <typename... Args>
-	static void PrintF(const string &str, Args... params) {
-		Printer::PrintF(OutputStream::STREAM_STDERR, str, std::forward<Args>(params)...);
+	template <typename... ARGS>
+	static void PrintF(const string &str, ARGS... params) {
+		Printer::PrintF(OutputStream::STREAM_STDERR, str, std::forward<ARGS>(params)...);
 	}
 	//! Directly prints the string to stdout without a newline
 	DUCKDB_API static void RawPrint(OutputStream stream, const string &str);