duckdb 0.8.1-dev51.0 → 0.8.1-dev96.0

package/src/duckdb/src/include/duckdb/catalog/catalog_entry.hpp

@@ -72,12 +72,12 @@ public:
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 

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

@@ -26,6 +26,17 @@ struct PrivateAllocatorData {
 	virtual ~PrivateAllocatorData();
 
 	unique_ptr<AllocatorDebugInfo> debug_info;
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 typedef data_ptr_t (*allocate_function_ptr_t)(PrivateAllocatorData *private_data, idx_t size);
@@ -85,14 +96,14 @@ public:
 		return AllocatedData(*this, AllocateData(size), size);
 	}
 	static data_ptr_t DefaultAllocate(PrivateAllocatorData *private_data, idx_t size) {
-		return (data_ptr_t)malloc(size);
+		return data_ptr_cast(malloc(size));
 	}
 	static void DefaultFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size) {
 		free(pointer);
 	}
 	static data_ptr_t DefaultReallocate(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
 	                                    idx_t size) {
-		return (data_ptr_t)realloc(pointer, size);
+		return data_ptr_cast(realloc(pointer, size));
 	}
 	static Allocator &Get(ClientContext &context);
 	static Allocator &Get(DatabaseInstance &db);
@@ -120,7 +131,7 @@ T *AllocateArray(idx_t size) {
 
 template <class T>
 void DeleteArray(T *ptr, idx_t size) {
-	Allocator::DefaultAllocator().FreeData((data_ptr_t)ptr, size * sizeof(T));
+	Allocator::DefaultAllocator().FreeData(data_ptr_cast(ptr), size * sizeof(T));
 }
 
 template <typename T, typename... ARGS>
@@ -132,7 +143,7 @@ T *AllocateObject(ARGS &&... args) {
 template <typename T>
 void DestroyObject(T *ptr) {
 	ptr->~T();
-	Allocator::DefaultAllocator().FreeData((data_ptr_t)ptr, sizeof(T));
+	Allocator::DefaultAllocator().FreeData(data_ptr_cast(ptr), sizeof(T));
 }
 
 //! The BufferAllocator is a wrapper around the global allocator class that sends any allocations made through the

package/src/duckdb/src/include/duckdb/common/arrow/arrow_buffer.hpp

@@ -73,12 +73,17 @@ struct ArrowBuffer {
 		return dataptr;
 	}
 
+	template <class T>
+	T *GetData() {
+		return reinterpret_cast<T *>(data());
+	}
+
 private:
 	void ReserveInternal(idx_t bytes) {
 		if (dataptr) {
-			dataptr = (data_ptr_t)realloc(dataptr, bytes);
+			dataptr = data_ptr_cast(realloc(dataptr, bytes));
 		} else {
-			dataptr = (data_ptr_t)malloc(bytes);
+			dataptr = data_ptr_cast(malloc(bytes));
 		}
 		capacity = bytes;
 	}

package/src/duckdb/src/include/duckdb/common/crypto/md5.hpp

@@ -26,10 +26,10 @@ public:
 	}
 	void Add(const char *data);
 	void Add(string_t string) {
-		MD5Update((const_data_ptr_t)string.GetData(), string.GetSize());
+		MD5Update(const_data_ptr_cast(string.GetData()), string.GetSize());
 	}
 	void Add(const string &data) {
-		MD5Update((const_data_ptr_t)data.c_str(), data.size());
+		MD5Update(const_data_ptr_cast(data.c_str()), data.size());
 	}
 
 	//! Write the 16-byte (binary) digest to the specified location

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

@@ -22,8 +22,8 @@ enum class PhysicalType : uint8_t;
 struct LogicalType;
 struct hugeint_t;
 
-inline void assert_restrict_function(void *left_start, void *left_end, void *right_start, void *right_end,
-                                     const char *fname, int linenr) {
+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) {
 	// assert that the two pointers do not overlap
 #ifdef DEBUG
 	if (!(left_end <= right_start || right_end <= left_start)) {

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

@@ -34,12 +34,12 @@ public:
 		static_assert(std::is_trivially_destructible<T>(), "WriteField object must be trivially destructible");
 
 		AddField();
-		WriteData((const_data_ptr_t)&element, sizeof(T));
+		WriteData(const_data_ptr_cast(&element), sizeof(T));
 	}
 
 	//! Write a string with a length prefix
 	void WriteString(const string &val) {
-		WriteStringLen((const_data_ptr_t)val.c_str(), val.size());
+		WriteStringLen(const_data_ptr_cast(val.c_str()), val.size());
 	}
 	void WriteStringLen(const_data_ptr_t val, idx_t len) {
 		AddField();
@@ -135,7 +135,7 @@ public:
 private:
 	template <class T>
 	void Write(const T &element) {
-		WriteData((const_data_ptr_t)&element, sizeof(T));
+		WriteData(const_data_ptr_cast(&element), sizeof(T));
 	}
 
 	DUCKDB_API void WriteData(const_data_ptr_t buffer, idx_t write_size);

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

@@ -77,6 +77,17 @@ public:
 		return path;
 	}
 
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+
 public:
 	FileSystem &file_system;
 	string path;

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

@@ -12,9 +12,8 @@ namespace duckdb {
 
 class FSSTPrimitives {
 public:
-	static string_t DecompressValue(void *duckdb_fsst_decoder, Vector &result, unsigned char *compressed_string,
+	static string_t DecompressValue(void *duckdb_fsst_decoder, Vector &result, const char *compressed_string,
 	                                idx_t compressed_string_len);
-	static Value DecompressValue(void *duckdb_fsst_decoder, unsigned char *compressed_string,
-	                             idx_t compressed_string_len);
+	static Value DecompressValue(void *duckdb_fsst_decoder, const char *compressed_string, idx_t compressed_string_len);
 };
 } // namespace duckdb

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

@@ -36,7 +36,7 @@ struct Radix {
 public:
 	static inline bool IsLittleEndian() {
 		int n = 1;
-		if (*(char *)&n == 1) {
+		if (*char_ptr_cast(&n) == 1) {
 			return true;
 		} else {
 			return false;
@@ -81,7 +81,7 @@ public:
 		if (x < -FLT_MAX) {
 			return 0;
 		}
-		buff = Load<uint32_t>((const_data_ptr_t)&x);
+		buff = Load<uint32_t>(const_data_ptr_cast(&x));
 		if ((buff & (1u << 31)) == 0) { //! +0 and positive numbers
 			buff |= (1u << 31);
 		} else {          //! negative numbers
@@ -111,7 +111,7 @@ public:
 		if (x < -DBL_MAX) {
 			return 0;
 		}
-		buff = Load<uint64_t>((const_data_ptr_t)&x);
+		buff = Load<uint64_t>(const_data_ptr_cast(&x));
 		if (buff < (1ull << 63)) { //! +0 and positive numbers
 			buff += (1ull << 63);
 		} else {          //! negative numbers

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

@@ -35,7 +35,7 @@ private:
 	template <class T>
 	T ReadPrimitive() {
 		T value;
-		ReadData((data_ptr_t)&value, sizeof(T));
+		ReadData(data_ptr_cast(&value), sizeof(T));
 		return value;
 	}
 

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

@@ -24,12 +24,15 @@ private:
 	template <class T>
 	void Write(T element) {
 		static_assert(std::is_trivially_destructible<T>(), "Write element must be trivially destructible");
-		WriteData((const_data_ptr_t)&element, sizeof(T));
+		WriteData(const_data_ptr_cast(&element), sizeof(T));
 	}
 	void WriteData(const_data_ptr_t buffer, idx_t write_size) {
 		data.insert(data.end(), buffer, buffer + write_size);
 		stack.back().size += write_size;
 	}
+	void WriteData(const char *ptr, idx_t write_size) {
+		WriteData(const_data_ptr_cast(ptr), write_size);
+	}
 
 	explicit BinarySerializer() {
 		serialize_enum_as_string = false;

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

@@ -46,16 +46,16 @@ public:
 	void Write(T element) {
 		static_assert(std::is_trivially_destructible<T>(), "Write element must be trivially destructible");
 
-		WriteData((const_data_ptr_t)&element, sizeof(T));
+		WriteData(const_data_ptr_cast(&element), sizeof(T));
 	}
 
 	//! Write data from a string buffer directly (without length prefix)
 	void WriteBufferData(const string &str) {
-		WriteData((const_data_ptr_t)str.c_str(), str.size());
+		WriteData(const_data_ptr_cast(str.c_str()), str.size());
 	}
 	//! Write a string with a length prefix
 	void WriteString(const string &val) {
-		WriteStringLen((const_data_ptr_t)val.c_str(), val.size());
+		WriteStringLen(const_data_ptr_cast(val.c_str()), val.size());
 	}
 	void WriteStringLen(const_data_ptr_t val, idx_t len) {
 		Write<uint32_t>((uint32_t)len);
@@ -127,7 +127,7 @@ public:
 	template <class T>
 	T Read() {
 		T value;
-		ReadData((data_ptr_t)&value, sizeof(T));
+		ReadData(data_ptr_cast(&value), sizeof(T));
 		return value;
 	}
 

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

@@ -28,4 +28,34 @@ typedef idx_t column_t;
 //! Type used for storage (column) identifiers
 typedef idx_t storage_t;
 
+template <class SRC>
+data_ptr_t data_ptr_cast(SRC *src) {
+	return reinterpret_cast<data_ptr_t>(src);
+}
+
+template <class SRC>
+const_data_ptr_t const_data_ptr_cast(const SRC *src) {
+	return reinterpret_cast<const_data_ptr_t>(src);
+}
+
+template <class SRC>
+char *char_ptr_cast(SRC *src) {
+	return reinterpret_cast<char *>(src);
+}
+
+template <class SRC>
+const char *const_char_ptr_cast(const SRC *src) {
+	return reinterpret_cast<const char *>(src);
+}
+
+template <class SRC>
+const unsigned char *const_uchar_ptr_cast(const SRC *src) {
+	return reinterpret_cast<const unsigned char *>(src);
+}
+
+template <class SRC>
+uintptr_t CastPointerToValue(SRC *src) {
+	return uintptr_t(src);
+}
+
 } // namespace duckdb

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

@@ -108,6 +108,18 @@ protected:
 	mutex lock;
 	shared_ptr<PartitionColumnDataAllocators> allocators;
 	vector<unique_ptr<ColumnDataCollection>> partitions;
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 } // namespace duckdb

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

@@ -12,6 +12,10 @@
 #include "duckdb/common/types/vector.hpp"
 #include "hyperloglog.hpp"
 
+namespace duckdb_hll {
+struct robj;
+}
+
 namespace duckdb {
 
 enum class HLLStorageType { UNCOMPRESSED = 1 };
@@ -58,9 +62,9 @@ public:
 	void AddToLog(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[]);
 
 private:
-	explicit HyperLogLog(void *hll);
+	explicit HyperLogLog(duckdb_hll::robj *hll);
 
-	void *hll;
+	duckdb_hll::robj *hll;
 	mutex lock;
 };
 } // namespace duckdb

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

@@ -42,7 +42,7 @@ inline string_t NullValue() {
 
 template <>
 inline char *NullValue() {
-	return (char *)NullValue<const char *>();
+	return (char *)NullValue<const char *>(); // NOLINT
 }
 
 template <>

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

@@ -135,6 +135,18 @@ protected:
 	mutex lock;
 	shared_ptr<PartitionTupleDataAllocators> allocators;
 	vector<unique_ptr<TupleDataCollection>> partitions;
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 } // namespace duckdb

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

@@ -55,7 +55,7 @@ public:
 #else
 			memset(value.pointer.prefix, 0, PREFIX_BYTES);
 #endif
-			value.pointer.ptr = (char *)data;
+			value.pointer.ptr = (char *)data; // NOLINT
 		}
 	}
 	string_t(const char *data) : string_t(data, strlen(data)) { // NOLINT: Allow implicit conversion from `const char*`
@@ -69,14 +69,14 @@ public:
 	}
 
 	const char *GetData() const {
-		return IsInlined() ? (const char *)value.inlined.inlined : value.pointer.ptr;
+		return IsInlined() ? const_char_ptr_cast(value.inlined.inlined) : value.pointer.ptr;
 	}
 	const char *GetDataUnsafe() const {
 		return GetData();
 	}
 
 	char *GetDataWriteable() const {
-		return IsInlined() ? (char *)value.inlined.inlined : value.pointer.ptr;
+		return IsInlined() ? (char *)value.inlined.inlined : value.pointer.ptr; // NOLINT
 	}
 
 	const char *GetPrefix() const {
@@ -110,7 +110,7 @@ public:
 		} else {
 			// copy the data into the prefix
 #ifndef DUCKDB_DEBUG_NO_INLINE
-			auto dataptr = (char *)GetData();
+			auto dataptr = GetData();
 			memcpy(value.pointer.prefix, dataptr, PREFIX_LENGTH);
 #else
 			memset(value.pointer.prefix, 0, PREFIX_BYTES);
@@ -128,15 +128,15 @@ public:
 				return false;
 			return (memcmp(a.GetData(), b.GetData(), a.GetSize()) == 0);
 #endif
-			uint64_t A = Load<uint64_t>((const_data_ptr_t)&a);
-			uint64_t B = Load<uint64_t>((const_data_ptr_t)&b);
+			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) {
 				// 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_t)&a + 8u);
-			B = Load<uint64_t>((const_data_ptr_t)&b + 8u);
+			A = Load<uint64_t>(const_data_ptr_cast(&a) + 8u);
+			B = Load<uint64_t>(const_data_ptr_cast(&b) + 8u);
 			if (A == B) {
 				// either they are both inlined (so compare equal) or point to the same string (so compare equal)
 				return true;
@@ -159,8 +159,8 @@ 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_t)left.GetPrefix());
-			uint32_t B = Load<uint32_t>((const_data_ptr_t)right.GetPrefix());
+			uint32_t A = Load<uint32_t>(const_data_ptr_cast(left.GetPrefix()));
+			uint32_t B = 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 {

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

@@ -166,7 +166,7 @@ public:
 	//! Create a blob Value from a data pointer and a length: no bytes are interpreted
 	DUCKDB_API static Value BLOB(const_data_ptr_t data, idx_t len);
 	static Value BLOB_RAW(const string &data) { // NOLINT
-		return Value::BLOB((const_data_ptr_t)data.c_str(), data.size());
+		return Value::BLOB(const_data_ptr_cast(data.c_str()), data.size());
 	}
 	//! Creates a blob by casting a specified string to a blob (i.e. interpreting \x characters)
 	DUCKDB_API static Value BLOB(const string &data);

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

@@ -24,6 +24,15 @@ struct UnifiedVectorFormat {
 	data_ptr_t data;
 	ValidityMask validity;
 	SelectionVector owned_sel;
+
+	template <class T>
+	static inline const T *GetData(const UnifiedVectorFormat &format) {
+		return reinterpret_cast<const T *>(format.data);
+	}
+	template <class T>
+	static inline T *GetDataNoConst(UnifiedVectorFormat &format) {
+		return reinterpret_cast<T *>(format.data);
+	}
 };
 
 class VectorCache;

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

@@ -52,7 +52,7 @@ public:
 		if (type != TARGET::TYPE) {
 			throw InternalException("Failed to cast vector auxiliary data to type - type mismatch");
 		}
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 
 	template <class TARGET>
@@ -60,7 +60,7 @@ public:
 		if (type != TARGET::TYPE) {
 			throw InternalException("Failed to cast vector auxiliary data to type - type mismatch");
 		}
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 
@@ -121,6 +121,18 @@ protected:
 	VectorBufferType buffer_type;
 	unique_ptr<VectorAuxiliaryData> aux_data;
 	unsafe_unique_array<data_t> data;
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 //! The DictionaryBuffer holds a selection vector
@@ -154,7 +166,7 @@ private:
 class VectorStringBuffer : public VectorBuffer {
 public:
 	VectorStringBuffer();
-	VectorStringBuffer(VectorBufferType type);
+	explicit VectorStringBuffer(VectorBufferType type);
 
 public:
 	string_t AddString(const char *data, idx_t len) {
@@ -207,7 +219,7 @@ private:
 class VectorStructBuffer : public VectorBuffer {
 public:
 	VectorStructBuffer();
-	VectorStructBuffer(const LogicalType &struct_type, idx_t capacity = STANDARD_VECTOR_SIZE);
+	explicit VectorStructBuffer(const LogicalType &struct_type, idx_t capacity = STANDARD_VECTOR_SIZE);
 	VectorStructBuffer(Vector &other, const SelectionVector &sel, idx_t count);
 	~VectorStructBuffer() override;
 
@@ -226,8 +238,8 @@ private:
 
 class VectorListBuffer : public VectorBuffer {
 public:
-	VectorListBuffer(unique_ptr<Vector> vector, idx_t initial_capacity = STANDARD_VECTOR_SIZE);
-	VectorListBuffer(const LogicalType &list_type, idx_t initial_capacity = STANDARD_VECTOR_SIZE);
+	explicit VectorListBuffer(unique_ptr<Vector> vector, idx_t initial_capacity = STANDARD_VECTOR_SIZE);
+	explicit VectorListBuffer(const LogicalType &list_type, idx_t initial_capacity = STANDARD_VECTOR_SIZE);
 	~VectorListBuffer() override;
 
 public:

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

@@ -39,7 +39,7 @@ private:
 	}
 
 	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static inline void UnaryFlatLoop(INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
+	static inline void UnaryFlatLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
 	                                 STATE_TYPE **__restrict states, ValidityMask &mask, idx_t count) {
 		if (!mask.AllValid()) {
 			idx_t base_idx = 0;
@@ -76,7 +76,7 @@ private:
 	}
 
 	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static inline void UnaryScatterLoop(INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
+	static inline void UnaryScatterLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
 	                                    STATE_TYPE **__restrict states, const SelectionVector &isel,
 	                                    const SelectionVector &ssel, ValidityMask &mask, idx_t count) {
 		if (OP::IgnoreNull() && !mask.AllValid()) {
@@ -99,7 +99,7 @@ private:
 	}
 
 	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static inline void UnaryFlatUpdateLoop(INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
+	static inline void UnaryFlatUpdateLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
 	                                       STATE_TYPE *__restrict state, idx_t count, ValidityMask &mask) {
 		idx_t base_idx = 0;
 		auto entry_count = ValidityMask::EntryCount(count);
@@ -129,7 +129,7 @@ private:
 	}
 
 	template <class STATE_TYPE, class INPUT_TYPE, class OP>
-	static inline void UnaryUpdateLoop(INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
+	static inline void UnaryUpdateLoop(const INPUT_TYPE *__restrict idata, AggregateInputData &aggr_input_data,
 	                                   STATE_TYPE *__restrict state, idx_t count, ValidityMask &mask,
 	                                   const SelectionVector &__restrict sel_vector) {
 		if (OP::IgnoreNull() && !mask.AllValid()) {
@@ -150,8 +150,8 @@ private:
 	}
 
 	template <class STATE_TYPE, class A_TYPE, class B_TYPE, class OP>
-	static inline void BinaryScatterLoop(A_TYPE *__restrict adata, AggregateInputData &aggr_input_data,
-	                                     B_TYPE *__restrict bdata, STATE_TYPE **__restrict states, idx_t count,
+	static inline void BinaryScatterLoop(const A_TYPE *__restrict adata, AggregateInputData &aggr_input_data,
+	                                     const B_TYPE *__restrict bdata, STATE_TYPE **__restrict states, idx_t count,
 	                                     const SelectionVector &asel, const SelectionVector &bsel,
 	                                     const SelectionVector &ssel, ValidityMask &avalidity,
 	                                     ValidityMask &bvalidity) {
@@ -179,8 +179,8 @@ private:
 	}
 
 	template <class STATE_TYPE, class A_TYPE, class B_TYPE, class OP>
-	static inline void BinaryUpdateLoop(A_TYPE *__restrict adata, AggregateInputData &aggr_input_data,
-	                                    B_TYPE *__restrict bdata, STATE_TYPE *__restrict state, idx_t count,
+	static inline void BinaryUpdateLoop(const A_TYPE *__restrict adata, AggregateInputData &aggr_input_data,
+	                                    const B_TYPE *__restrict bdata, STATE_TYPE *__restrict state, idx_t count,
 	                                    const SelectionVector &asel, const SelectionVector &bsel,
 	                                    ValidityMask &avalidity, ValidityMask &bvalidity) {
 		if (OP::IgnoreNull() && (!avalidity.AllValid() || !bvalidity.AllValid())) {
@@ -248,9 +248,9 @@ public:
 			UnifiedVectorFormat idata, sdata;
 			input.ToUnifiedFormat(count, idata);
 			states.ToUnifiedFormat(count, sdata);
-			UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP>((INPUT_TYPE *)idata.data, aggr_input_data,
-			                                             (STATE_TYPE **)sdata.data, *idata.sel, *sdata.sel,
-			                                             idata.validity, count);
+			UnaryScatterLoop<STATE_TYPE, INPUT_TYPE, OP>(UnifiedVectorFormat::GetData<INPUT_TYPE>(idata),
+			                                             aggr_input_data, (STATE_TYPE **)sdata.data, *idata.sel,
+			                                             *sdata.sel, idata.validity, count);
 		}
 	}
 
@@ -275,8 +275,9 @@ public:
 		default: {
 			UnifiedVectorFormat idata;
 			input.ToUnifiedFormat(count, idata);
-			UnaryUpdateLoop<STATE_TYPE, INPUT_TYPE, OP>((INPUT_TYPE *)idata.data, aggr_input_data, (STATE_TYPE *)state,
-			                                            count, idata.validity, *idata.sel);
+			UnaryUpdateLoop<STATE_TYPE, INPUT_TYPE, OP>(UnifiedVectorFormat::GetData<INPUT_TYPE>(idata),
+			                                            aggr_input_data, (STATE_TYPE *)state, count, idata.validity,
+			                                            *idata.sel);
 			break;
 		}
 		}
@@ -290,9 +291,9 @@ public:
 		b.ToUnifiedFormat(count, bdata);
 		states.ToUnifiedFormat(count, sdata);
 
-		BinaryScatterLoop<STATE_TYPE, A_TYPE, B_TYPE, OP>((A_TYPE *)adata.data, aggr_input_data, (B_TYPE *)bdata.data,
-		                                                  (STATE_TYPE **)sdata.data, count, *adata.sel, *bdata.sel,
-		                                                  *sdata.sel, adata.validity, bdata.validity);
+		BinaryScatterLoop<STATE_TYPE, A_TYPE, B_TYPE, OP>(
+		    UnifiedVectorFormat::GetData<A_TYPE>(adata), aggr_input_data, UnifiedVectorFormat::GetData<B_TYPE>(bdata),
+		    (STATE_TYPE **)sdata.data, count, *adata.sel, *bdata.sel, *sdata.sel, adata.validity, bdata.validity);
 	}
 
 	template <class STATE_TYPE, class A_TYPE, class B_TYPE, class OP>
@@ -302,9 +303,9 @@ public:
 		a.ToUnifiedFormat(count, adata);
 		b.ToUnifiedFormat(count, bdata);
 
-		BinaryUpdateLoop<STATE_TYPE, A_TYPE, B_TYPE, OP>((A_TYPE *)adata.data, aggr_input_data, (B_TYPE *)bdata.data,
-		                                                 (STATE_TYPE *)state, count, *adata.sel, *bdata.sel,
-		                                                 adata.validity, bdata.validity);
+		BinaryUpdateLoop<STATE_TYPE, A_TYPE, B_TYPE, OP>(
+		    UnifiedVectorFormat::GetData<A_TYPE>(adata), aggr_input_data, UnifiedVectorFormat::GetData<B_TYPE>(bdata),
+		    (STATE_TYPE *)state, count, *adata.sel, *bdata.sel, adata.validity, bdata.validity);
 	}
 
 	template <class STATE_TYPE, class OP>