duckdb 0.8.1-dev31.0 → 0.8.1-dev341.0

package/src/duckdb/src/common/row_operations/row_radix_scatter.cpp

@@ -9,7 +9,7 @@ template <class T>
 void TemplatedRadixScatter(UnifiedVectorFormat &vdata, const SelectionVector &sel, idx_t add_count,
                            data_ptr_t *key_locations, const bool desc, const bool has_null, const bool nulls_first,
                            const idx_t offset) {
-	auto source = (T *)vdata.data;
+	auto source = UnifiedVectorFormat::GetData<T>(vdata);
 	if (has_null) {
 		auto &validity = vdata.validity;
 		const data_t valid = nulls_first ? 1 : 0;
@@ -54,7 +54,7 @@ void TemplatedRadixScatter(UnifiedVectorFormat &vdata, const SelectionVector &se
 void RadixScatterStringVector(UnifiedVectorFormat &vdata, const SelectionVector &sel, idx_t add_count,
                               data_ptr_t *key_locations, const bool desc, const bool has_null, const bool nulls_first,
                               const idx_t prefix_len, idx_t offset) {
-	auto source = (string_t *)vdata.data;
+	auto source = UnifiedVectorFormat::GetData<string_t>(vdata);
 	if (has_null) {
 		auto &validity = vdata.validity;
 		const data_t valid = nulls_first ? 1 : 0;

package/src/duckdb/src/common/row_operations/row_scatter.cpp

@@ -20,7 +20,7 @@ using ValidityBytes = RowLayout::ValidityBytes;
 template <class T>
 static void TemplatedScatter(UnifiedVectorFormat &col, Vector &rows, const SelectionVector &sel, const idx_t count,
                              const idx_t col_offset, const idx_t col_no) {
-	auto data = (T *)col.data;
+	auto data = UnifiedVectorFormat::GetData<T>(col);
 	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
 
 	if (!col.validity.AllValid()) {
@@ -50,7 +50,7 @@ static void TemplatedScatter(UnifiedVectorFormat &col, Vector &rows, const Selec
 
 static void ComputeStringEntrySizes(const UnifiedVectorFormat &col, idx_t entry_sizes[], const SelectionVector &sel,
                                     const idx_t count, const idx_t offset = 0) {
-	auto data = (const string_t *)col.data;
+	auto data = UnifiedVectorFormat::GetData<string_t>(col);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = sel.get_index(i);
 		auto col_idx = col.sel->get_index(idx) + offset;
@@ -64,7 +64,7 @@ static void ComputeStringEntrySizes(const UnifiedVectorFormat &col, idx_t entry_
 static void ScatterStringVector(UnifiedVectorFormat &col, Vector &rows, data_ptr_t str_locations[],
                                 const SelectionVector &sel, const idx_t count, const idx_t col_offset,
                                 const idx_t col_no) {
-	auto string_data = (string_t *)col.data;
+	auto string_data = UnifiedVectorFormat::GetData<string_t>(col);
 	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
 
 	// Write out zero length to avoid swizzling problems.
@@ -81,7 +81,7 @@ static void ScatterStringVector(UnifiedVectorFormat &col, Vector &rows, data_ptr
 			Store<string_t>(string_data[col_idx], row + col_offset);
 		} else {
 			const auto &str = string_data[col_idx];
-			string_t inserted((const char *)str_locations[i], str.GetSize());
+			string_t inserted(const_char_ptr_cast(str_locations[i]), str.GetSize());
 			memcpy(inserted.GetDataWriteable(), str.GetData(), str.GetSize());
 			str_locations[i] += str.GetSize();
 			inserted.Finalize();

package/src/duckdb/src/common/serializer/binary_deserializer.cpp

@@ -125,7 +125,7 @@ string BinaryDeserializer::ReadString() {
 	}
 	auto buffer = make_unsafe_uniq_array<data_t>(size);
 	ReadData(buffer.get(), size);
-	return string((char *)buffer.get(), size);
+	return string(const_char_ptr_cast(buffer.get()), size);
 }
 
 interval_t BinaryDeserializer::ReadInterval() {

package/src/duckdb/src/common/serializer/binary_serializer.cpp

@@ -129,7 +129,7 @@ void BinarySerializer::WriteValue(const string &value) {
 	auto len = value.length();
 	Write<uint32_t>((uint32_t)len);
 	if (len > 0) {
-		WriteData((const_data_ptr_t)value.c_str(), len);
+		WriteData(value.c_str(), len);
 	}
 }
 
@@ -137,7 +137,7 @@ void BinarySerializer::WriteValue(const string_t value) {
 	auto len = value.GetSize();
 	Write<uint32_t>((uint32_t)len);
 	if (len > 0) {
-		WriteData((const_data_ptr_t)value.GetDataUnsafe(), len);
+		WriteData(value.GetDataUnsafe(), len);
 	}
 }
 
@@ -145,7 +145,7 @@ void BinarySerializer::WriteValue(const char *value) {
 	auto len = strlen(value);
 	Write<uint32_t>((uint32_t)len);
 	if (len > 0) {
-		WriteData((const_data_ptr_t)value, len);
+		WriteData(value, len);
 	}
 }
 

package/src/duckdb/src/common/serializer.cpp

@@ -10,7 +10,7 @@ string Deserializer::Read() {
 	}
 	auto buffer = make_unsafe_uniq_array<data_t>(size);
 	ReadData(buffer.get(), size);
-	return string((char *)buffer.get(), size);
+	return string(const_char_ptr_cast(buffer.get()), size);
 }
 
 void Deserializer::ReadStringVector(vector<string> &list) {

package/src/duckdb/src/common/sort/comparators.cpp

@@ -167,7 +167,7 @@ int Comparators::CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right
 	uint32_t right_string_size = Load<uint32_t>(right_ptr);
 	left_ptr += sizeof(uint32_t);
 	right_ptr += sizeof(uint32_t);
-	auto memcmp_res = memcmp((const char *)left_ptr, (const char *)right_ptr,
+	auto memcmp_res = memcmp(const_char_ptr_cast(left_ptr), const_char_ptr_cast(right_ptr),
 	                         std::min<uint32_t>(left_string_size, right_string_size));
 
 	left_ptr += left_string_size;

package/src/duckdb/src/common/sort/merge_sorter.cpp

@@ -544,7 +544,9 @@ void MergeSorter::MergeData(SortedData &result_data, SortedData &l_data, SortedD
 					const bool &l_smaller = left_smaller[copied + i];
 					const bool r_smaller = !l_smaller;
 					const auto &entry_size = next_entry_sizes[copied + i];
-					memcpy(result_heap_ptr, (data_ptr_t)(l_smaller * (idx_t)l_heap_ptr + r_smaller * (idx_t)r_heap_ptr),
+					memcpy(result_heap_ptr,
+					       reinterpret_cast<data_ptr_t>(l_smaller * CastPointerToValue(l_heap_ptr) +
+					                                    r_smaller * CastPointerToValue(r_heap_ptr)),
 					       entry_size);
 					D_ASSERT(Load<uint32_t>(result_heap_ptr) == entry_size);
 					result_heap_ptr += entry_size;
@@ -585,7 +587,10 @@ void MergeSorter::MergeRows(data_ptr_t &l_ptr, idx_t &l_entry_idx, const idx_t &
 		const bool &l_smaller = left_smaller[copied + i];
 		const bool r_smaller = !l_smaller;
 		// Use comparison bool (0 or 1) to copy an entry from either side
-		FastMemcpy(target_ptr, (data_ptr_t)(l_smaller * (idx_t)l_ptr + r_smaller * (idx_t)r_ptr), entry_size);
+		FastMemcpy(
+		    target_ptr,
+		    reinterpret_cast<data_ptr_t>(l_smaller * CastPointerToValue(l_ptr) + r_smaller * CastPointerToValue(r_ptr)),
+		    entry_size);
 		target_ptr += entry_size;
 		// Use the comparison bool to increment entries and pointers
 		l_entry_idx += l_smaller;

package/src/duckdb/src/common/sort/partition_state.cpp

@@ -124,8 +124,8 @@ void PartitionGlobalSinkState::ResizeGroupingData(idx_t cardinality) {
 
 void PartitionGlobalSinkState::SyncLocalPartition(GroupingPartition &local_partition, GroupingAppend &local_append) {
 	// We are done if the local_partition is right sized.
-	auto local_radix = (RadixPartitionedColumnData *)local_partition.get();
-	if (local_radix->GetRadixBits() == grouping_data->GetRadixBits()) {
+	auto &local_radix = local_partition->Cast<RadixPartitionedColumnData>();
+	if (local_radix.GetRadixBits() == grouping_data->GetRadixBits()) {
 		return;
 	}
 

package/src/duckdb/src/common/types/bit.cpp

@@ -20,7 +20,7 @@ idx_t Bit::ComputeBitstringLen(idx_t len) {
 }
 
 static inline idx_t GetBitPadding(const string_t &bit_string) {
-	auto data = (const_data_ptr_t)bit_string.GetData();
+	auto data = const_data_ptr_cast(bit_string.GetData());
 	D_ASSERT(idx_t(data[0]) <= 8);
 	return data[0];
 }
@@ -61,7 +61,7 @@ void Bit::SetEmptyBitString(string_t &target, idx_t len) {
 
 // **** casting functions ****
 void Bit::ToString(string_t bits, char *output) {
-	auto data = (const_data_ptr_t)bits.GetData();
+	auto data = const_data_ptr_cast(bits.GetData());
 	auto len = bits.GetSize();
 
 	idx_t padding = GetBitPadding(bits);
@@ -84,7 +84,7 @@ string Bit::ToString(string_t str) {
 }
 
 bool Bit::TryGetBitStringSize(string_t str, idx_t &str_len, string *error_message) {
-	auto data = (const_data_ptr_t)str.GetData();
+	auto data = const_data_ptr_cast(str.GetData());
 	auto len = str.GetSize();
 	str_len = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -92,7 +92,7 @@ bool Bit::TryGetBitStringSize(string_t str, idx_t &str_len, string *error_messag
 			str_len++;
 		} else {
 			string error = StringUtil::Format("Invalid character encountered in string -> bit conversion: '%s'",
-			                                  string((char *)data + i, 1));
+			                                  string(const_char_ptr_cast(data) + i, 1));
 			HandleCastError::AssignError(error, error_message);
 			return false;
 		}
@@ -107,7 +107,7 @@ bool Bit::TryGetBitStringSize(string_t str, idx_t &str_len, string *error_messag
 }
 
 void Bit::ToBit(string_t str, string_t &output_str) {
-	auto data = (const_data_ptr_t)str.GetData();
+	auto data = const_data_ptr_cast(str.GetData());
 	auto len = str.GetSize();
 	auto output = output_str.GetDataWriteable();
 

package/src/duckdb/src/common/types/blob.cpp

@@ -24,7 +24,7 @@ bool IsRegularCharacter(data_t c) {
 }
 
 idx_t Blob::GetStringSize(string_t blob) {
-	auto data = (const_data_ptr_t)blob.GetData();
+	auto data = const_data_ptr_cast(blob.GetData());
 	auto len = blob.GetSize();
 	idx_t str_len = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -40,7 +40,7 @@ idx_t Blob::GetStringSize(string_t blob) {
 }
 
 void Blob::ToString(string_t blob, char *output) {
-	auto data = (const_data_ptr_t)blob.GetData();
+	auto data = const_data_ptr_cast(blob.GetData());
 	auto len = blob.GetSize();
 	idx_t str_idx = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -70,7 +70,7 @@ string Blob::ToString(string_t blob) {
 }
 
 bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) {
-	auto data = (const_data_ptr_t)str.GetData();
+	auto data = const_data_ptr_cast(str.GetData());
 	auto len = str.GetSize();
 	str_len = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -84,7 +84,7 @@ bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) {
 			if (data[i + 1] != 'x' || Blob::HEX_MAP[data[i + 2]] < 0 || Blob::HEX_MAP[data[i + 3]] < 0) {
 				string error =
 				    StringUtil::Format("Invalid hex escape code encountered in string -> blob conversion: %s",
-				                       string((char *)data + i, 4));
+				                       string(const_char_ptr_cast(data) + i, 4));
 				HandleCastError::AssignError(error, error_message);
 				return false;
 			}
@@ -112,7 +112,7 @@ idx_t Blob::GetBlobSize(string_t str) {
 }
 
 void Blob::ToBlob(string_t str, data_ptr_t output) {
-	auto data = (const_data_ptr_t)str.GetData();
+	auto data = const_data_ptr_cast(str.GetData());
 	auto len = str.GetSize();
 	idx_t blob_idx = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -137,7 +137,7 @@ void Blob::ToBlob(string_t str, data_ptr_t output) {
 string Blob::ToBlob(string_t str) {
 	auto blob_len = GetBlobSize(str);
 	auto buffer = make_unsafe_uniq_array<char>(blob_len);
-	Blob::ToBlob(str, (data_ptr_t)buffer.get());
+	Blob::ToBlob(str, data_ptr_cast(buffer.get()));
 	return string(buffer.get(), blob_len);
 }
 
@@ -149,7 +149,7 @@ idx_t Blob::ToBase64Size(string_t blob) {
 }
 
 void Blob::ToBase64(string_t blob, char *output) {
-	auto input_data = (const_data_ptr_t)blob.GetData();
+	auto input_data = const_data_ptr_cast(blob.GetData());
 	auto input_size = blob.GetSize();
 	idx_t out_idx = 0;
 	idx_t i;
@@ -239,7 +239,7 @@ uint32_t DecodeBase64Bytes(const string_t &str, const_data_ptr_t input_data, idx
 
 void Blob::FromBase64(string_t str, data_ptr_t output, idx_t output_size) {
 	D_ASSERT(output_size == FromBase64Size(str));
-	auto input_data = (const_data_ptr_t)str.GetData();
+	auto input_data = const_data_ptr_cast(str.GetData());
 	auto input_size = str.GetSize();
 	if (input_size == 0) {
 		return;

package/src/duckdb/src/common/types/column/column_data_allocator.cpp

@@ -71,7 +71,7 @@ BufferHandle ColumnDataAllocator::AllocateBlock(idx_t size) {
 void ColumnDataAllocator::AllocateEmptyBlock(idx_t size) {
 	auto allocation_amount = MaxValue<idx_t>(NextPowerOfTwo(size), 4096);
 	if (!blocks.empty()) {
-		auto last_capacity = blocks.back().capacity;
+		idx_t last_capacity = blocks.back().capacity;
 		auto next_capacity = MinValue<idx_t>(last_capacity * 2, last_capacity + Storage::BLOCK_SIZE);
 		allocation_amount = MaxValue<idx_t>(next_capacity, allocation_amount);
 	}
@@ -162,10 +162,10 @@ data_ptr_t ColumnDataAllocator::GetDataPointer(ChunkManagementState &state, uint
 		// in-memory allocator: construct pointer from block_id and offset
 		if (sizeof(uintptr_t) == sizeof(uint32_t)) {
 			uintptr_t pointer_value = uintptr_t(block_id);
-			return (data_ptr_t)pointer_value;
+			return (data_ptr_t)pointer_value; // NOLINT - convert from pointer value back to pointer
 		} else if (sizeof(uintptr_t) == sizeof(uint64_t)) {
 			uintptr_t pointer_value = (uintptr_t(offset) << 32) | uintptr_t(block_id);
-			return (data_ptr_t)pointer_value;
+			return (data_ptr_t)pointer_value; // NOLINT - convert from pointer value back to pointer
 		} else {
 			throw InternalException("ColumnDataCollection: Architecture not supported!?");
 		}
@@ -196,7 +196,7 @@ void ColumnDataAllocator::UnswizzlePointers(ChunkManagementState &state, Vector
 	// at least one string must be non-inlined, otherwise this function should not be called
 	D_ASSERT(i < end);
 
-	auto base_ptr = (char *)GetDataPointer(state, block_id, offset);
+	auto base_ptr = char_ptr_cast(GetDataPointer(state, block_id, offset));
 	if (strings[i].GetData() == base_ptr) {
 		// pointers are still valid
 		return;

package/src/duckdb/src/common/types/column/column_data_collection.cpp

@@ -454,7 +454,7 @@ void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVector
 		// 'append_count' is less if we cannot fit that amount of non-inlined strings on one buffer-managed block
 		idx_t append_count;
 		idx_t heap_size = 0;
-		const auto source_entries = (string_t *)source_data.data;
+		const auto source_entries = UnifiedVectorFormat::GetData<string_t>(source_data);
 		for (append_count = 0; append_count < vector_remaining; append_count++) {
 			auto source_idx = source_data.sel->get_index(offset + append_count);
 			if (!source_data.validity.RowIsValid(source_idx)) {
@@ -505,7 +505,7 @@ void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVector
 			target_validity.SetAllValid(STANDARD_VECTOR_SIZE);
 		}
 
-		auto target_entries = (string_t *)base_ptr;
+		auto target_entries = reinterpret_cast<string_t *>(base_ptr);
 		for (idx_t i = 0; i < append_count; i++) {
 			auto source_idx = source_data.sel->get_index(offset + i);
 			auto target_idx = current_segment.count + i;
@@ -520,7 +520,7 @@ void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVector
 			} else {
 				D_ASSERT(heap_ptr != nullptr);
 				memcpy(heap_ptr, source_entry.GetData(), source_entry.GetSize());
-				target_entry = string_t((const char *)heap_ptr, source_entry.GetSize());
+				target_entry = string_t(const_char_ptr_cast(heap_ptr), source_entry.GetSize());
 				heap_ptr += source_entry.GetSize();
 			}
 		}

package/src/duckdb/src/common/types/column/column_data_collection_segment.cpp

@@ -14,7 +14,7 @@ idx_t ColumnDataCollectionSegment::GetDataSize(idx_t type_size) {
 }
 
 validity_t *ColumnDataCollectionSegment::GetValidityPointer(data_ptr_t base_ptr, idx_t type_size) {
-	return (validity_t *)(base_ptr + GetDataSize(type_size));
+	return reinterpret_cast<validity_t *>(base_ptr + GetDataSize(type_size));
 }
 
 VectorDataIndex ColumnDataCollectionSegment::AllocateVectorInternal(const LogicalType &type, ChunkMetaData &chunk_meta,

package/src/duckdb/src/common/types/column/partitioned_column_data.cpp

@@ -19,9 +19,9 @@ PartitionedColumnData::PartitionedColumnData(const PartitionedColumnData &other)
 unique_ptr<PartitionedColumnData> PartitionedColumnData::CreateShared() {
 	switch (type) {
 	case PartitionedColumnDataType::RADIX:
-		return make_uniq<RadixPartitionedColumnData>((RadixPartitionedColumnData &)*this);
+		return make_uniq<RadixPartitionedColumnData>(Cast<RadixPartitionedColumnData>());
 	case PartitionedColumnDataType::HIVE:
-		return make_uniq<HivePartitionedColumnData>((HivePartitionedColumnData &)*this);
+		return make_uniq<HivePartitionedColumnData>(Cast<HivePartitionedColumnData>());
 	default:
 		throw NotImplementedException("CreateShared for this type of PartitionedColumnData");
 	}

package/src/duckdb/src/common/types/hash.cpp

@@ -40,7 +40,7 @@ template <>
 hash_t Hash(float val) {
 	static_assert(sizeof(float) == sizeof(uint32_t), "");
 	FloatingPointEqualityTransform<float>::OP(val);
-	uint32_t uval = Load<uint32_t>((const_data_ptr_t)&val);
+	uint32_t uval = Load<uint32_t>(const_data_ptr_cast(&val));
 	return murmurhash64(uval);
 }
 
@@ -48,7 +48,7 @@ template <>
 hash_t Hash(double val) {
 	static_assert(sizeof(double) == sizeof(uint64_t), "");
 	FloatingPointEqualityTransform<double>::OP(val);
-	uint64_t uval = Load<uint64_t>((const_data_ptr_t)&val);
+	uint64_t uval = Load<uint64_t>(const_data_ptr_cast(&val));
 	return murmurhash64(uval);
 }
 

package/src/duckdb/src/common/types/hyperloglog.cpp

@@ -9,18 +9,18 @@ namespace duckdb {
 HyperLogLog::HyperLogLog() : hll(nullptr) {
 	hll = duckdb_hll::hll_create();
 	// Insert into a dense hll can be vectorized, sparse cannot, so we immediately convert
-	duckdb_hll::hllSparseToDense((duckdb_hll::robj *)hll);
+	duckdb_hll::hllSparseToDense(hll);
 }
 
-HyperLogLog::HyperLogLog(void *hll) : hll(hll) {
+HyperLogLog::HyperLogLog(duckdb_hll::robj *hll) : hll(hll) {
 }
 
 HyperLogLog::~HyperLogLog() {
-	duckdb_hll::hll_destroy((duckdb_hll::robj *)hll);
+	duckdb_hll::hll_destroy(hll);
 }
 
 void HyperLogLog::Add(data_ptr_t element, idx_t size) {
-	if (duckdb_hll::hll_add((duckdb_hll::robj *)hll, element, size) == HLL_C_ERR) {
+	if (duckdb_hll::hll_add(hll, element, size) == HLL_C_ERR) {
 		throw InternalException("Could not add to HLL?");
 	}
 }
@@ -29,7 +29,7 @@ idx_t HyperLogLog::Count() const {
 	// exception from size_t ban
 	size_t result;
 
-	if (duckdb_hll::hll_count((duckdb_hll::robj *)hll, &result) != HLL_C_OK) {
+	if (duckdb_hll::hll_count(hll, &result) != HLL_C_OK) {
 		throw InternalException("Could not count HLL?");
 	}
 	return result;
@@ -37,24 +37,24 @@ idx_t HyperLogLog::Count() const {
 
 unique_ptr<HyperLogLog> HyperLogLog::Merge(HyperLogLog &other) {
 	duckdb_hll::robj *hlls[2];
-	hlls[0] = (duckdb_hll::robj *)hll;
-	hlls[1] = (duckdb_hll::robj *)other.hll;
+	hlls[0] = hll;
+	hlls[1] = other.hll;
 	auto new_hll = duckdb_hll::hll_merge(hlls, 2);
 	if (!new_hll) {
 		throw InternalException("Could not merge HLLs");
 	}
-	return unique_ptr<HyperLogLog>(new HyperLogLog((void *)new_hll));
+	return unique_ptr<HyperLogLog>(new HyperLogLog(new_hll));
 }
 
 HyperLogLog *HyperLogLog::MergePointer(HyperLogLog &other) {
 	duckdb_hll::robj *hlls[2];
-	hlls[0] = (duckdb_hll::robj *)hll;
-	hlls[1] = (duckdb_hll::robj *)other.hll;
+	hlls[0] = hll;
+	hlls[1] = other.hll;
 	auto new_hll = duckdb_hll::hll_merge(hlls, 2);
 	if (!new_hll) {
 		throw Exception("Could not merge HLLs");
 	}
-	return new HyperLogLog((void *)new_hll);
+	return new HyperLogLog(new_hll);
 }
 
 unique_ptr<HyperLogLog> HyperLogLog::Merge(HyperLogLog logs[], idx_t count) {
@@ -63,13 +63,13 @@ unique_ptr<HyperLogLog> HyperLogLog::Merge(HyperLogLog logs[], idx_t count) {
 	};
 	auto hlls = hlls_uptr.get();
 	for (idx_t i = 0; i < count; i++) {
-		hlls[i] = (duckdb_hll::robj *)logs[i].hll;
+		hlls[i] = logs[i].hll;
 	}
 	auto new_hll = duckdb_hll::hll_merge(hlls, count);
 	if (!new_hll) {
 		throw InternalException("Could not merge HLLs");
 	}
-	return unique_ptr<HyperLogLog>(new HyperLogLog((void *)new_hll));
+	return unique_ptr<HyperLogLog>(new HyperLogLog(new_hll));
 }
 
 idx_t HyperLogLog::GetSize() {
@@ -77,7 +77,7 @@ idx_t HyperLogLog::GetSize() {
 }
 
 data_ptr_t HyperLogLog::GetPtr() const {
-	return (data_ptr_t)((duckdb_hll::robj *)hll)->ptr;
+	return data_ptr_cast((hll)->ptr);
 }
 
 unique_ptr<HyperLogLog> HyperLogLog::Copy() {
@@ -123,21 +123,22 @@ inline uint64_t TemplatedHash(const T &elem) {
 
 template <>
 inline uint64_t TemplatedHash(const hugeint_t &elem) {
-	return TemplatedHash<uint64_t>(Load<uint64_t>((data_ptr_t)&elem.upper)) ^ TemplatedHash<uint64_t>(elem.lower);
+	return TemplatedHash<uint64_t>(Load<uint64_t>(const_data_ptr_cast(&elem.upper))) ^
+	       TemplatedHash<uint64_t>(elem.lower);
 }
 
 template <idx_t rest>
-inline void CreateIntegerRecursive(const data_ptr_t &data, uint64_t &x) {
+inline void CreateIntegerRecursive(const_data_ptr_t &data, uint64_t &x) {
 	x ^= (uint64_t)data[rest - 1] << ((rest - 1) * 8);
 	return CreateIntegerRecursive<rest - 1>(data, x);
 }
 
 template <>
-inline void CreateIntegerRecursive<1>(const data_ptr_t &data, uint64_t &x) {
+inline void CreateIntegerRecursive<1>(const_data_ptr_t &data, uint64_t &x) {
 	x ^= (uint64_t)data[0];
 }
 
-inline uint64_t HashOtherSize(const data_ptr_t &data, const idx_t &len) {
+inline uint64_t HashOtherSize(const_data_ptr_t &data, const idx_t &len) {
 	uint64_t x = 0;
 	switch (len & 7) {
 	case 7:
@@ -169,7 +170,7 @@ inline uint64_t HashOtherSize(const data_ptr_t &data, const idx_t &len) {
 
 template <>
 inline uint64_t TemplatedHash(const string_t &elem) {
-	data_ptr_t data = (data_ptr_t)elem.GetData();
+	auto data = const_data_ptr_cast(elem.GetData());
 	const auto &len = elem.GetSize();
 	uint64_t h = 0;
 	for (idx_t i = 0; i + sizeof(uint64_t) <= len; i += sizeof(uint64_t)) {
@@ -194,7 +195,7 @@ inline uint64_t TemplatedHash(const string_t &elem) {
 
 template <class T>
 void TemplatedComputeHashes(UnifiedVectorFormat &vdata, const idx_t &count, uint64_t hashes[]) {
-	T *data = (T *)vdata.data;
+	auto data = UnifiedVectorFormat::GetData<T>(vdata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = vdata.sel->get_index(i);
 		if (vdata.validity.RowIsValid(idx)) {
@@ -262,7 +263,7 @@ void HyperLogLog::ProcessEntries(UnifiedVectorFormat &vdata, const LogicalType &
 
 void HyperLogLog::AddToLogs(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[],
                             HyperLogLog **logs[], const SelectionVector *log_sel) {
-	AddToLogsInternal(vdata, count, indices, counts, (void ****)logs, log_sel);
+	AddToLogsInternal(vdata, count, indices, counts, reinterpret_cast<void ****>(logs), log_sel);
 }
 
 void HyperLogLog::AddToLog(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[]) {