duckdb 0.10.2-dev0.0 → 0.10.2-dev5.0

package/src/duckdb/src/include/duckdb/common/types/row/partitioned_tuple_data.hpp

@@ -181,7 +181,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);
 	}
 };

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_layout.hpp

@@ -50,6 +50,9 @@ public:
 	inline Aggregates &GetAggregates() {
 		return aggregates;
 	}
+	const inline Aggregates &GetAggregates() const {
+		return aggregates;
+	}
 	//! Returns a map from column id to the struct TupleDataLayout
 	const inline TupleDataLayout &GetStructLayout(idx_t col_idx) const {
 		D_ASSERT(struct_layouts->find(col_idx) != struct_layouts->end());
@@ -89,7 +92,11 @@ public:
 	}
 	//! Returns whether any of the aggregates have a destructor
 	inline bool HasDestructor() const {
-		return has_destructor;
+		return !aggr_destructor_idxs.empty();
+	}
+	//! Returns the indices of the aggregates that have destructors
+	inline const vector<idx_t> &GetAggregateDestructorIndices() const {
+		return aggr_destructor_idxs;
 	}
 
 private:
@@ -113,8 +120,8 @@ private:
 	bool all_constant;
 	//! Offset to the heap size of every row
 	idx_t heap_size_offset;
-	//! Whether any of the aggregates have a destructor
-	bool has_destructor;
+	//! Indices of aggregate functions that have a destructor
+	vector<idx_t> aggr_destructor_idxs;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_segment.hpp

@@ -22,7 +22,7 @@ class TupleDataLayout;
 
 struct TupleDataChunkPart {
 public:
-	TupleDataChunkPart(mutex &lock);
+	explicit TupleDataChunkPart(mutex &lock);
 
 	//! Disable copy constructors
 	TupleDataChunkPart(const TupleDataChunkPart &other) = delete;

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

@@ -43,7 +43,7 @@ struct SelectionVector {
 	explicit SelectionVector(buffer_ptr<SelectionData> data) {
 		Initialize(std::move(data));
 	}
-	SelectionVector &operator=(SelectionVector &&other) {
+	SelectionVector &operator=(SelectionVector &&other) noexcept {
 		sel_vector = other.sel_vector;
 		other.sel_vector = nullptr;
 		selection_data = std::move(other.selection_data);
@@ -83,24 +83,24 @@ public:
 		sel_vector = other.sel_vector;
 	}
 
-	inline void set_index(idx_t idx, idx_t loc) {
+	inline void set_index(idx_t idx, idx_t loc) { // NOLINT: allow casing for legacy reasons
 		sel_vector[idx] = UnsafeNumericCast<sel_t>(loc);
 	}
-	inline void swap(idx_t i, idx_t j) {
+	inline void swap(idx_t i, idx_t j) { // NOLINT: allow casing for legacy reasons
 		sel_t tmp = sel_vector[i];
 		sel_vector[i] = sel_vector[j];
 		sel_vector[j] = tmp;
 	}
-	inline idx_t get_index(idx_t idx) const {
+	inline idx_t get_index(idx_t idx) const { // NOLINT: allow casing for legacy reasons
 		return sel_vector ? sel_vector[idx] : idx;
 	}
-	sel_t *data() {
+	sel_t *data() { // NOLINT: allow casing for legacy reasons
 		return sel_vector;
 	}
-	const sel_t *data() const {
+	const sel_t *data() const { // NOLINT: allow casing for legacy reasons
 		return sel_vector;
 	}
-	buffer_ptr<SelectionData> sel_data() {
+	buffer_ptr<SelectionData> sel_data() { // NOLINT: allow casing for legacy reasons
 		return selection_data;
 	}
 	buffer_ptr<SelectionData> Slice(const SelectionVector &sel, idx_t count) const;
@@ -119,7 +119,7 @@ private:
 
 class OptionalSelection {
 public:
-	explicit inline OptionalSelection(SelectionVector *sel_p) {
+	explicit OptionalSelection(SelectionVector *sel_p) {
 		Initialize(sel_p);
 	}
 	void Initialize(SelectionVector *sel_p) {
@@ -130,7 +130,7 @@ public:
 		}
 	}
 
-	inline operator SelectionVector *() {
+	inline operator SelectionVector *() { // NOLINT: allow implicit conversion to SelectionVector
 		return sel;
 	}
 
@@ -169,10 +169,10 @@ public:
 	bool Initialized() const {
 		return initialized;
 	}
-	void Initialize(idx_t size) {
+	void Initialize(idx_t new_size) {
 		D_ASSERT(!initialized);
-		this->size = size;
-		sel_vec.Initialize(size);
+		this->size = new_size;
+		sel_vec.Initialize(new_size);
 		internal_opt_selvec.Initialize(&sel_vec);
 		initialized = true;
 	}

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

@@ -18,7 +18,7 @@ namespace duckdb {
 //! returned pointer will remain valid until the StringHeap is destroyed
 class StringHeap {
 public:
-	DUCKDB_API StringHeap(Allocator &allocator = Allocator::DefaultAllocator());
+	DUCKDB_API explicit StringHeap(Allocator &allocator = Allocator::DefaultAllocator());
 
 	DUCKDB_API void Destroy();
 	DUCKDB_API void Move(StringHeap &other);

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

@@ -14,6 +14,7 @@
 #include "duckdb/common/numeric_utils.hpp"
 
 #include <cstring>
+#include <algorithm>
 
 namespace duckdb {
 
@@ -60,13 +61,11 @@ public:
 		}
 	}
 
-	string_t(const char *data)
-	    : string_t(data,
-	               UnsafeNumericCast<uint32_t>(strlen(data))) { // NOLINT: Allow implicit conversion from `const char*`
+	string_t(const char *data) // NOLINT: Allow implicit conversion from `const char*`
+	    : string_t(data, UnsafeNumericCast<uint32_t>(strlen(data))) {
 	}
-	string_t(const string &value)
-	    : string_t(value.c_str(),
-	               UnsafeNumericCast<uint32_t>(value.size())) { // NOLINT: Allow implicit conversion from `const char*`
+	string_t(const string &value) // NOLINT: Allow implicit conversion from `const char*`
+	    : string_t(value.c_str(), UnsafeNumericCast<uint32_t>(value.size())) {
 	}
 
 	bool IsInlined() const {
@@ -88,8 +87,8 @@ public:
 		return value.inlined.inlined;
 	}
 
-	char *GetPrefixWriteable() const {
-		return (char *)value.inlined.inlined;
+	char *GetPrefixWriteable() {
+		return value.inlined.inlined;
 	}
 
 	idx_t GetSize() const {
@@ -142,20 +141,21 @@ public:
 	struct StringComparisonOperators {
 		static inline bool Equals(const string_t &a, const string_t &b) {
 #ifdef DUCKDB_DEBUG_NO_INLINE
-			if (a.GetSize() != b.GetSize())
+			if (a.GetSize() != b.GetSize()) {
 				return false;
+			}
 			return (memcmp(a.GetData(), b.GetData(), a.GetSize()) == 0);
 #endif
-			uint64_t A = Load<uint64_t>(const_data_ptr_cast(&a));
-			uint64_t B = Load<uint64_t>(const_data_ptr_cast(&b));
-			if (A != B) {
+			uint64_t a_bulk_comp = Load<uint64_t>(const_data_ptr_cast(&a));
+			uint64_t b_bulk_comp = Load<uint64_t>(const_data_ptr_cast(&b));
+			if (a_bulk_comp != b_bulk_comp) {
 				// Either length or prefix are different -> not equal
 				return false;
 			}
 			// they have the same length and same prefix!
-			A = Load<uint64_t>(const_data_ptr_cast(&a) + 8u);
-			B = Load<uint64_t>(const_data_ptr_cast(&b) + 8u);
-			if (A == B) {
+			a_bulk_comp = Load<uint64_t>(const_data_ptr_cast(&a) + 8u);
+			b_bulk_comp = Load<uint64_t>(const_data_ptr_cast(&b) + 8u);
+			if (a_bulk_comp == b_bulk_comp) {
 				// either they are both inlined (so compare equal) or point to the same string (so compare equal)
 				return true;
 			}
@@ -177,11 +177,11 @@ public:
 			const uint32_t min_length = std::min<uint32_t>(left_length, right_length);
 
 #ifndef DUCKDB_DEBUG_NO_INLINE
-			uint32_t A = Load<uint32_t>(const_data_ptr_cast(left.GetPrefix()));
-			uint32_t B = Load<uint32_t>(const_data_ptr_cast(right.GetPrefix()));
+			uint32_t a_prefix = Load<uint32_t>(const_data_ptr_cast(left.GetPrefix()));
+			uint32_t b_prefix = Load<uint32_t>(const_data_ptr_cast(right.GetPrefix()));
 
 			// Utility to move 0xa1b2c3d4 into 0xd4c3b2a1, basically inverting the order byte-a-byte
-			auto bswap = [](uint32_t v) -> uint32_t {
+			auto byte_swap = [](uint32_t v) -> uint32_t {
 				uint32_t t1 = (v >> 16u) | (v << 16u);
 				uint32_t t2 = t1 & 0x00ff00ff;
 				uint32_t t3 = t1 & 0xff00ff00;
@@ -194,8 +194,9 @@ public:
 			// 	if the prefix is smaller(after bswap), it will stay smaller regardless of the extra bytes
 			//	if the prefix is equal, the extra bytes are guaranteed to be /0 for the shorter one
 
-			if (A != B)
-				return bswap(A) > bswap(B);
+			if (a_prefix != b_prefix) {
+				return byte_swap(a_prefix) > byte_swap(b_prefix);
+			}
 #endif
 			auto memcmp_res = memcmp(left.GetData(), right.GetData(), min_length);
 			return memcmp_res > 0 || (memcmp_res == 0 && left_length > right_length);

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

@@ -14,8 +14,8 @@
 
 namespace duckdb {
 
-struct dtime_t;
-struct dtime_tz_t;
+struct dtime_t;    // NOLINT
+struct dtime_tz_t; // NOLINT
 
 //! The Time class is a static class that holds helper functions for the Time
 //! type.

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

@@ -18,9 +18,9 @@
 
 namespace duckdb {
 
-struct date_t;
-struct dtime_t;
-struct dtime_tz_t;
+struct date_t;     // NOLINT
+struct dtime_t;    // NOLINT
+struct dtime_tz_t; // NOLINT
 
 //! Type used to represent timestamps (seconds,microseconds,milliseconds or nanoseconds since 1970-01-01)
 struct timestamp_t { // NOLINT

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

@@ -20,7 +20,7 @@ class UUID {
 public:
 	constexpr static const uint8_t STRING_SIZE = 36;
 	//! Convert a uuid string to a hugeint object
-	static bool FromString(string str, hugeint_t &result);
+	static bool FromString(const string &str, hugeint_t &result);
 	//! Convert a uuid string to a hugeint object
 	static bool FromCString(const char *str, idx_t len, hugeint_t &result) {
 		return FromString(string(str, 0, len), result);
@@ -42,7 +42,7 @@ public:
 		return string(buff, STRING_SIZE);
 	}
 
-	static hugeint_t FromString(string str) {
+	static hugeint_t FromString(const string &str) {
 		hugeint_t result;
 		FromString(str, result);
 		return result;

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

@@ -191,13 +191,13 @@ public:
 	DUCKDB_API static Value BIT(const string &data);
 
 	//! Creates an aggregate state
-	DUCKDB_API static Value AGGREGATE_STATE(const LogicalType &type, const_data_ptr_t data, idx_t len);
+	DUCKDB_API static Value AGGREGATE_STATE(const LogicalType &type, const_data_ptr_t data, idx_t len); // NOLINT
 
 	template <class T>
 	T GetValue() const;
 	template <class T>
 	static Value CreateValue(T value) {
-		static_assert(AlwaysFalse<T>::value, "No specialization exists for this type");
+		static_assert(AlwaysFalse<T>::VALUE, "No specialization exists for this type");
 		return Value(nullptr);
 	}
 	// Returns the internal value. Unlike GetValue(), this method does not perform casting, and assumes T matches the

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

@@ -83,9 +83,9 @@ public:
 	//! Create a vector that references the other vector
 	DUCKDB_API Vector(Vector &other);
 	//! Create a vector that slices another vector
-	DUCKDB_API explicit Vector(Vector &other, const SelectionVector &sel, idx_t count);
+	DUCKDB_API explicit Vector(const Vector &other, const SelectionVector &sel, idx_t count);
 	//! Create a vector that slices another vector between a pair of offsets
-	DUCKDB_API explicit Vector(Vector &other, idx_t offset, idx_t end);
+	DUCKDB_API explicit Vector(const Vector &other, idx_t offset, idx_t end);
 	//! Create a vector of size one holding the passed on value
 	DUCKDB_API explicit Vector(const Value &value);
 	//! Create a vector of size tuple_count (non-standard)
@@ -291,19 +291,19 @@ struct ConstantVector {
 struct DictionaryVector {
 	static inline const SelectionVector &SelVector(const Vector &vector) {
 		D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
-		return ((const DictionaryBuffer &)*vector.buffer).GetSelVector();
+		return vector.buffer->Cast<DictionaryBuffer>().GetSelVector();
 	}
 	static inline SelectionVector &SelVector(Vector &vector) {
 		D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
-		return ((DictionaryBuffer &)*vector.buffer).GetSelVector();
+		return vector.buffer->Cast<DictionaryBuffer>().GetSelVector();
 	}
 	static inline const Vector &Child(const Vector &vector) {
 		D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
-		return ((const VectorChildBuffer &)*vector.auxiliary).data;
+		return vector.auxiliary->Cast<VectorChildBuffer>().data;
 	}
 	static inline Vector &Child(Vector &vector) {
 		D_ASSERT(vector.GetVectorType() == VectorType::DICTIONARY_VECTOR);
-		return ((VectorChildBuffer &)*vector.auxiliary).data;
+		return vector.auxiliary->Cast<VectorChildBuffer>().data;
 	}
 };
 
@@ -390,6 +390,10 @@ struct ListVector {
 	DUCKDB_API static void GetConsecutiveChildSelVector(Vector &list, SelectionVector &sel, idx_t offset, idx_t count);
 	//! Share the entry of the other list vector
 	DUCKDB_API static void ReferenceEntry(Vector &vector, Vector &other);
+
+private:
+	template <class T>
+	static T &GetEntryInternal(T &vector);
 };
 
 struct StringVector {
@@ -493,6 +497,10 @@ struct ArrayVector {
 	DUCKDB_API static Vector &GetEntry(Vector &vector);
 	//! Gets the total size of the underlying child-vector of an array
 	DUCKDB_API static idx_t GetTotalSize(const Vector &vector);
+
+private:
+	template <class T>
+	static T &GetEntryInternal(T &vector);
 };
 
 enum class UnionInvalidReason : uint8_t {
@@ -552,7 +560,7 @@ struct UnionVector {
 struct SequenceVector {
 	static void GetSequence(const Vector &vector, int64_t &start, int64_t &increment, int64_t &sequence_count) {
 		D_ASSERT(vector.GetVectorType() == VectorType::SEQUENCE_VECTOR);
-		auto data = (int64_t *)vector.buffer->GetData();
+		auto data = reinterpret_cast<int64_t *>(vector.buffer->GetData());
 		start = data[0];
 		increment = data[1];
 		sequence_count = data[2];

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

@@ -131,7 +131,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);
 	}
 };

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

@@ -24,7 +24,7 @@ class TypeCatalogEntry;
 class Vector;
 class ClientContext;
 
-struct string_t;
+struct string_t; // NOLINT: mimic std casing
 
 template <class T>
 using child_list_t = vector<std::pair<std::string, T>>;
@@ -32,12 +32,12 @@ using child_list_t = vector<std::pair<std::string, T>>;
 template <class T>
 using buffer_ptr = shared_ptr<T>;
 
-template <class T, typename... Args>
-buffer_ptr<T> make_buffer(Args &&...args) {
-	return make_shared<T>(std::forward<Args>(args)...);
+template <class T, typename... ARGS>
+buffer_ptr<T> make_buffer(ARGS &&...args) { // NOLINT: mimic std casing
+	return make_shared<T>(std::forward<ARGS>(args)...);
 }
 
-struct list_entry_t {
+struct list_entry_t { // NOLINT: mimic std casing
 	list_entry_t() = default;
 	list_entry_t(uint64_t offset, uint64_t length) : offset(offset), length(length) {
 	}
@@ -234,7 +234,7 @@ enum class LogicalTypeId : uint8_t {
 
 struct ExtraTypeInfo;
 
-struct aggregate_state_t;
+struct aggregate_state_t; // NOLINT: mimic std casing
 
 struct LogicalType {
 	DUCKDB_API LogicalType();
@@ -245,7 +245,7 @@ struct LogicalType {
 
 	DUCKDB_API ~LogicalType();
 
-	inline LogicalTypeId id() const {
+	inline LogicalTypeId id() const { // NOLINT: mimic std casing
 		return id_;
 	}
 	inline PhysicalType InternalType() const {
@@ -279,6 +279,9 @@ struct LogicalType {
 
 	// copy assignment
 	inline LogicalType &operator=(const LogicalType &other) {
+		if (this == &other) {
+			return *this;
+		}
 		id_ = other.id_;
 		physical_type_ = other.physical_type_;
 		type_info_ = other.type_info_;
@@ -337,9 +340,9 @@ struct LogicalType {
 	bool Contains(LogicalTypeId type_id) const;
 
 private:
-	LogicalTypeId id_;
-	PhysicalType physical_type_;
-	shared_ptr<ExtraTypeInfo> type_info_;
+	LogicalTypeId id_; // NOLINT: allow this naming for legacy reasons
+	PhysicalType physical_type_; // NOLINT: allow this naming for legacy reasons
+	shared_ptr<ExtraTypeInfo> type_info_; // NOLINT: allow this naming for legacy reasons
 
 private:
 	PhysicalType GetInternalType();
@@ -520,6 +523,7 @@ bool ApproxEqual(double l, double r);
 struct aggregate_state_t {
 	aggregate_state_t() {
 	}
+	// NOLINTNEXTLINE: work around bug in clang-tidy
 	aggregate_state_t(string function_name_p, LogicalType return_type_p, vector<LogicalType> bound_argument_types_p)
 	    : function_name(std::move(function_name_p)), return_type(std::move(return_type_p)),
 	      bound_argument_types(std::move(bound_argument_types_p)) {

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

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

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

@@ -29,7 +29,7 @@ public:
 		vector<unique_ptr<READER_TYPE>> union_readers;
 		case_insensitive_map_t<idx_t> union_names_map;
 		for (idx_t file_idx = 0; file_idx < files.size(); ++file_idx) {
-			const auto file_name = files[file_idx];
+			const auto &file_name = files[file_idx];
 			auto reader = make_uniq<READER_TYPE>(context, file_name, options);
 
 			auto &col_names = reader->GetNames();

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

@@ -9,11 +9,11 @@
 
 namespace duckdb {
 
-template <class _Tp, class _Dp = std::default_delete<_Tp>, bool SAFE = true>
-class unique_ptr : public std::unique_ptr<_Tp, _Dp> {
+template <class DATA_TYPE, class ALLOCATOR_TYPE = std::default_delete<DATA_TYPE>, bool SAFE = true>
+class unique_ptr : public std::unique_ptr<DATA_TYPE, ALLOCATOR_TYPE> { // NOLINT: naming
 public:
-	using original = std::unique_ptr<_Tp, _Dp>;
-	using original::original;
+	using original = std::unique_ptr<DATA_TYPE, ALLOCATOR_TYPE>;
+	using original::original; // NOLINT
 
 private:
 	static inline void AssertNotNull(const bool null) {
@@ -27,17 +27,17 @@ private:
 	}
 
 public:
-	typename std::add_lvalue_reference<_Tp>::type operator*() const {
+	typename std::add_lvalue_reference<DATA_TYPE>::type operator*() const { // NOLINT: hiding on purpose
 		const auto ptr = original::get();
-		if (MemorySafety<SAFE>::enabled) {
+		if (MemorySafety<SAFE>::ENABLED) {
 			AssertNotNull(!ptr);
 		}
 		return *ptr;
 	}
 
-	typename original::pointer operator->() const {
+	typename original::pointer operator->() const { // NOLINT: hiding on purpose
 		const auto ptr = original::get();
-		if (MemorySafety<SAFE>::enabled) {
+		if (MemorySafety<SAFE>::ENABLED) {
 			AssertNotNull(!ptr);
 		}
 		return ptr;
@@ -48,15 +48,16 @@ public:
 	[[clang::reinitializes]]
 #endif
 	inline void
-	reset(typename original::pointer ptr = typename original::pointer()) noexcept {
+	reset(typename original::pointer ptr = typename original::pointer()) noexcept { // NOLINT: hiding on purpose
 		original::reset(ptr);
 	}
 };
 
-template <class _Tp, class _Dp, bool SAFE>
-class unique_ptr<_Tp[], _Dp, SAFE> : public std::unique_ptr<_Tp[], std::default_delete<_Tp[]>> {
+template <class DATA_TYPE, class ALLOCATOR_TYPE, bool SAFE>
+class unique_ptr<DATA_TYPE[], ALLOCATOR_TYPE, SAFE>
+    : public std::unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>> {
 public:
-	using original = std::unique_ptr<_Tp[], std::default_delete<_Tp[]>>;
+	using original = std::unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>>;
 	using original::original;
 
 private:
@@ -71,9 +72,9 @@ private:
 	}
 
 public:
-	typename std::add_lvalue_reference<_Tp>::type operator[](size_t __i) const {
+	typename std::add_lvalue_reference<DATA_TYPE>::type operator[](size_t __i) const { // NOLINT: hiding on purpose
 		const auto ptr = original::get();
-		if (MemorySafety<SAFE>::enabled) {
+		if (MemorySafety<SAFE>::ENABLED) {
 			AssertNotNull(!ptr);
 		}
 		return ptr[__i];

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

@@ -17,10 +17,10 @@
 
 namespace duckdb {
 
-template <class _Tp, bool SAFE = true>
-class vector : public std::vector<_Tp, std::allocator<_Tp>> {
+template <class DATA_TYPE, bool SAFE = true>
+class vector : public std::vector<DATA_TYPE, std::allocator<DATA_TYPE>> { // NOLINT: matching name of std
 public:
-	using original = std::vector<_Tp, std::allocator<_Tp>>;
+	using original = std::vector<DATA_TYPE, std::allocator<DATA_TYPE>>;
 	using original::original;
 	using size_type = typename original::size_type;
 	using const_reference = typename original::const_reference;
@@ -43,59 +43,59 @@ public:
 	[[clang::reinitializes]]
 #endif
 	inline void
-	clear() noexcept {
+	clear() noexcept { // NOLINT: hiding on purpose
 		original::clear();
 	}
 
 	// Because we create the other constructor, the implicitly created constructor
 	// gets deleted, so we have to be explicit
 	vector() = default;
-	vector(original &&other) : original(std::move(other)) {
+	vector(original &&other) : original(std::move(other)) { // NOLINT: allow implicit conversion
 	}
-	template <bool _SAFE>
-	vector(vector<_Tp, _SAFE> &&other) : original(std::move(other)) {
+	template <bool INTERNAL_SAFE>
+	vector(vector<DATA_TYPE, INTERNAL_SAFE> &&other) : original(std::move(other)) { // NOLINT: allow implicit conversion
 	}
 
-	template <bool _SAFE = false>
-	inline typename original::reference get(typename original::size_type __n) {
-		if (MemorySafety<_SAFE>::enabled) {
+	template <bool INTERNAL_SAFE = false>
+	inline typename original::reference get(typename original::size_type __n) { // NOLINT: hiding on purpose
+		if (MemorySafety<INTERNAL_SAFE>::ENABLED) {
 			AssertIndexInBounds(__n, original::size());
 		}
 		return original::operator[](__n);
 	}
 
-	template <bool _SAFE = false>
-	inline typename original::const_reference get(typename original::size_type __n) const {
-		if (MemorySafety<_SAFE>::enabled) {
+	template <bool INTERNAL_SAFE = false>
+	inline typename original::const_reference get(typename original::size_type __n) const { // NOLINT: hiding on purpose
+		if (MemorySafety<INTERNAL_SAFE>::ENABLED) {
 			AssertIndexInBounds(__n, original::size());
 		}
 		return original::operator[](__n);
 	}
 
-	typename original::reference operator[](typename original::size_type __n) {
+	typename original::reference operator[](typename original::size_type __n) { // NOLINT: hiding on purpose
 		return get<SAFE>(__n);
 	}
-	typename original::const_reference operator[](typename original::size_type __n) const {
+	typename original::const_reference operator[](typename original::size_type __n) const { // NOLINT: hiding on purpose
 		return get<SAFE>(__n);
 	}
 
-	typename original::reference front() {
+	typename original::reference front() { // NOLINT: hiding on purpose
 		return get<SAFE>(0);
 	}
 
-	typename original::const_reference front() const {
+	typename original::const_reference front() const { // NOLINT: hiding on purpose
 		return get<SAFE>(0);
 	}
 
-	typename original::reference back() {
-		if (MemorySafety<SAFE>::enabled && original::empty()) {
+	typename original::reference back() { // NOLINT: hiding on purpose
+		if (MemorySafety<SAFE>::ENABLED && original::empty()) {
 			throw InternalException("'back' called on an empty vector!");
 		}
 		return get<SAFE>(original::size() - 1);
 	}
 
-	typename original::const_reference back() const {
-		if (MemorySafety<SAFE>::enabled && original::empty()) {
+	typename original::const_reference back() const { // NOLINT: hiding on purpose
+		if (MemorySafety<SAFE>::ENABLED && original::empty()) {
 			throw InternalException("'back' called on an empty vector!");
 		}
 		return get<SAFE>(original::size() - 1);

package/src/duckdb/src/include/duckdb/common/vector_operations/aggregate_executor.hpp

@@ -444,6 +444,8 @@ public:
 				op.Right(i, limit);
 				break;
 			case 0x03:
+			default:
+				D_ASSERT(overlap == 0x03);
 				// i ∈ F ∩ P
 				limit = MinValue(right->end, left->end);
 				op.Both(i, limit);

package/src/duckdb/src/include/duckdb/common/vector_operations/general_cast.hpp

@@ -24,7 +24,8 @@ struct VectorTryCastData {
 
 struct HandleVectorCastError {
 	template <class RESULT_TYPE>
-	static RESULT_TYPE Operation(string error_message, ValidityMask &mask, idx_t idx, VectorTryCastData &cast_data) {
+	static RESULT_TYPE Operation(const string &error_message, ValidityMask &mask, idx_t idx,
+	                             VectorTryCastData &cast_data) {
 		HandleCastError::AssignError(error_message, cast_data.parameters);
 		cast_data.all_converted = false;
 		mask.SetInvalid(idx);

package/src/duckdb/src/include/duckdb/common/vector_operations/generic_executor.hpp

@@ -26,10 +26,9 @@ struct PrimitiveTypeState {
 
 template <class INPUT_TYPE>
 struct PrimitiveType {
-	PrimitiveType() {
+	PrimitiveType() = default;
+	PrimitiveType(INPUT_TYPE val) : val(val) { // NOLINT: allow implicit cast
 	}
-	PrimitiveType(INPUT_TYPE val) : val(val) {
-	} // NOLINT: allow implicit cast
 
 	INPUT_TYPE val;