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

package/src/duckdb/src/common/fsst.cpp

@@ -4,27 +4,32 @@
 #include "fsst.h"
 
 namespace duckdb {
-string_t FSSTPrimitives::DecompressValue(void *duckdb_fsst_decoder, Vector &result, unsigned char *compressed_string,
+
+string_t FSSTPrimitives::DecompressValue(void *duckdb_fsst_decoder, Vector &result, const char *compressed_string,
                                          idx_t compressed_string_len) {
 	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
 	unsigned char decompress_buffer[StringUncompressed::STRING_BLOCK_LIMIT + 1];
+	auto fsst_decoder = reinterpret_cast<duckdb_fsst_decoder_t *>(duckdb_fsst_decoder);
+	auto compressed_string_ptr = (unsigned char *)compressed_string; // NOLINT
 	auto decompressed_string_size =
-	    duckdb_fsst_decompress((duckdb_fsst_decoder_t *)duckdb_fsst_decoder, compressed_string_len, compressed_string,
+	    duckdb_fsst_decompress(fsst_decoder, compressed_string_len, compressed_string_ptr,
 	                           StringUncompressed::STRING_BLOCK_LIMIT + 1, &decompress_buffer[0]);
 	D_ASSERT(decompressed_string_size <= StringUncompressed::STRING_BLOCK_LIMIT);
 
-	return StringVector::AddStringOrBlob(result, (const char *)decompress_buffer, decompressed_string_size);
+	return StringVector::AddStringOrBlob(result, const_char_ptr_cast(decompress_buffer), decompressed_string_size);
 }
 
-Value FSSTPrimitives::DecompressValue(void *duckdb_fsst_decoder, unsigned char *compressed_string,
+Value FSSTPrimitives::DecompressValue(void *duckdb_fsst_decoder, const char *compressed_string,
                                       idx_t compressed_string_len) {
 	unsigned char decompress_buffer[StringUncompressed::STRING_BLOCK_LIMIT + 1];
+	auto compressed_string_ptr = (unsigned char *)compressed_string; // NOLINT
+	auto fsst_decoder = reinterpret_cast<duckdb_fsst_decoder_t *>(duckdb_fsst_decoder);
 	auto decompressed_string_size =
-	    duckdb_fsst_decompress((duckdb_fsst_decoder_t *)duckdb_fsst_decoder, compressed_string_len, compressed_string,
+	    duckdb_fsst_decompress(fsst_decoder, compressed_string_len, compressed_string_ptr,
 	                           StringUncompressed::STRING_BLOCK_LIMIT + 1, &decompress_buffer[0]);
 	D_ASSERT(decompressed_string_size <= StringUncompressed::STRING_BLOCK_LIMIT);
 
-	return Value(string((char *)decompress_buffer, decompressed_string_size));
+	return Value(string(char_ptr_cast(decompress_buffer), decompressed_string_size));
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/gzip_file_system.cpp

@@ -183,19 +183,19 @@ bool MiniZStreamWrapper::Read(StreamData &sd) {
 	}
 
 	// actually decompress
-	mz_stream_ptr->next_in = (data_ptr_t)sd.in_buff_start;
+	mz_stream_ptr->next_in = sd.in_buff_start;
 	D_ASSERT(sd.in_buff_end - sd.in_buff_start < NumericLimits<int32_t>::Maximum());
 	mz_stream_ptr->avail_in = (uint32_t)(sd.in_buff_end - sd.in_buff_start);
-	mz_stream_ptr->next_out = (data_ptr_t)sd.out_buff_end;
+	mz_stream_ptr->next_out = data_ptr_cast(sd.out_buff_end);
 	mz_stream_ptr->avail_out = (uint32_t)((sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_end);
 	auto ret = duckdb_miniz::mz_inflate(mz_stream_ptr, duckdb_miniz::MZ_NO_FLUSH);
 	if (ret != duckdb_miniz::MZ_OK && ret != duckdb_miniz::MZ_STREAM_END) {
 		throw IOException("Failed to decode gzip stream: %s", duckdb_miniz::mz_error(ret));
 	}
 	// update pointers following inflate()
-	sd.in_buff_start = (data_ptr_t)mz_stream_ptr->next_in;
+	sd.in_buff_start = (data_ptr_t)mz_stream_ptr->next_in; // NOLINT
 	sd.in_buff_end = sd.in_buff_start + mz_stream_ptr->avail_in;
-	sd.out_buff_end = (data_ptr_t)mz_stream_ptr->next_out;
+	sd.out_buff_end = data_ptr_cast(mz_stream_ptr->next_out);
 	D_ASSERT(sd.out_buff_end + mz_stream_ptr->avail_out == sd.out_buff.get() + sd.out_buf_size);
 
 	// if stream ended, deallocate inflator
@@ -221,14 +221,14 @@ bool MiniZStreamWrapper::Read(StreamData &sd) {
 void MiniZStreamWrapper::Write(CompressedFile &file, StreamData &sd, data_ptr_t uncompressed_data,
                                int64_t uncompressed_size) {
 	// update the src and the total size
-	crc = duckdb_miniz::mz_crc32(crc, (const unsigned char *)uncompressed_data, uncompressed_size);
+	crc = duckdb_miniz::mz_crc32(crc, reinterpret_cast<const unsigned char *>(uncompressed_data), uncompressed_size);
 	total_size += uncompressed_size;
 
 	auto remaining = uncompressed_size;
 	while (remaining > 0) {
 		idx_t output_remaining = (sd.out_buff.get() + sd.out_buf_size) - sd.out_buff_start;
 
-		mz_stream_ptr->next_in = (const unsigned char *)uncompressed_data;
+		mz_stream_ptr->next_in = reinterpret_cast<const unsigned char *>(uncompressed_data);
 		mz_stream_ptr->avail_in = remaining;
 		mz_stream_ptr->next_out = sd.out_buff_start;
 		mz_stream_ptr->avail_out = output_remaining;
@@ -360,7 +360,7 @@ string GZipFileSystem::UncompressGZIPString(const string &in) {
 	}
 
 	auto bytes_remaining = in.size() - (body_ptr - in.data());
-	mz_stream_ptr->next_in = (unsigned char *)body_ptr;
+	mz_stream_ptr->next_in = const_uchar_ptr_cast(body_ptr);
 	mz_stream_ptr->avail_in = bytes_remaining;
 
 	unsigned char decompress_buffer[BUFSIZ];
@@ -373,7 +373,7 @@ string GZipFileSystem::UncompressGZIPString(const string &in) {
 		if (status != duckdb_miniz::MZ_STREAM_END && status != duckdb_miniz::MZ_OK) {
 			throw IOException("Failed to uncompress");
 		}
-		decompressed.append((char *)decompress_buffer, mz_stream_ptr->total_out - decompressed.size());
+		decompressed.append(char_ptr_cast(decompress_buffer), mz_stream_ptr->total_out - decompressed.size());
 	}
 	duckdb_miniz::mz_inflateEnd(mz_stream_ptr);
 	if (decompressed.empty()) {

package/src/duckdb/src/common/hive_partitioning.cpp

@@ -183,7 +183,7 @@ static void TemplatedGetHivePartitionValues(Vector &input, vector<HivePartitionK
 	input.ToUnifiedFormat(count, format);
 
 	const auto &sel = *format.sel;
-	const auto data = (T *)format.data;
+	const auto data = UnifiedVectorFormat::GetData<T>(format);
 	const auto &validity = format.validity;
 
 	const auto &type = input.GetType();

package/src/duckdb/src/common/local_file_system.cpp

@@ -242,7 +242,7 @@ unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path_p, uint8_t f
 }
 
 void LocalFileSystem::SetFilePointer(FileHandle &handle, idx_t location) {
-	int fd = ((UnixFileHandle &)handle).fd;
+	int fd = handle.Cast<UnixFileHandle>().fd;
 	off_t offset = lseek(fd, location, SEEK_SET);
 	if (offset == (off_t)-1) {
 		throw IOException("Could not seek to location %lld for file \"%s\": %s", location, handle.path,
@@ -251,7 +251,7 @@ void LocalFileSystem::SetFilePointer(FileHandle &handle, idx_t location) {
 }
 
 idx_t LocalFileSystem::GetFilePointer(FileHandle &handle) {
-	int fd = ((UnixFileHandle &)handle).fd;
+	int fd = handle.Cast<UnixFileHandle>().fd;
 	off_t position = lseek(fd, 0, SEEK_CUR);
 	if (position == (off_t)-1) {
 		throw IOException("Could not get file position file \"%s\": %s", handle.path, strerror(errno));
@@ -260,7 +260,7 @@ idx_t LocalFileSystem::GetFilePointer(FileHandle &handle) {
 }
 
 void LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	int fd = ((UnixFileHandle &)handle).fd;
+	int fd = handle.Cast<UnixFileHandle>().fd;
 	int64_t bytes_read = pread(fd, buffer, nr_bytes, location);
 	if (bytes_read == -1) {
 		throw IOException("Could not read from file \"%s\": %s", handle.path, strerror(errno));
@@ -272,7 +272,7 @@ void LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, i
 }
 
 int64_t LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	int fd = ((UnixFileHandle &)handle).fd;
+	int fd = handle.Cast<UnixFileHandle>().fd;
 	int64_t bytes_read = read(fd, buffer, nr_bytes);
 	if (bytes_read == -1) {
 		throw IOException("Could not read from file \"%s\": %s", handle.path, strerror(errno));
@@ -281,7 +281,7 @@ int64_t LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes
 }
 
 void LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) {
-	int fd = ((UnixFileHandle &)handle).fd;
+	int fd = handle.Cast<UnixFileHandle>().fd;
 	int64_t bytes_written = pwrite(fd, buffer, nr_bytes, location);
 	if (bytes_written == -1) {
 		throw IOException("Could not write file \"%s\": %s", handle.path, strerror(errno));
@@ -293,7 +293,7 @@ void LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes,
 }
 
 int64_t LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	int fd = ((UnixFileHandle &)handle).fd;
+	int fd = handle.Cast<UnixFileHandle>().fd;
 	int64_t bytes_written = write(fd, buffer, nr_bytes);
 	if (bytes_written == -1) {
 		throw IOException("Could not write file \"%s\": %s", handle.path, strerror(errno));
@@ -302,7 +302,7 @@ int64_t LocalFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_byte
 }
 
 int64_t LocalFileSystem::GetFileSize(FileHandle &handle) {
-	int fd = ((UnixFileHandle &)handle).fd;
+	int fd = handle.Cast<UnixFileHandle>().fd;
 	struct stat s;
 	if (fstat(fd, &s) == -1) {
 		return -1;
@@ -311,7 +311,7 @@ int64_t LocalFileSystem::GetFileSize(FileHandle &handle) {
 }
 
 time_t LocalFileSystem::GetLastModifiedTime(FileHandle &handle) {
-	int fd = ((UnixFileHandle &)handle).fd;
+	int fd = handle.Cast<UnixFileHandle>().fd;
 	struct stat s;
 	if (fstat(fd, &s) == -1) {
 		return -1;
@@ -320,12 +320,12 @@ time_t LocalFileSystem::GetLastModifiedTime(FileHandle &handle) {
 }
 
 FileType LocalFileSystem::GetFileType(FileHandle &handle) {
-	int fd = ((UnixFileHandle &)handle).fd;
+	int fd = handle.Cast<UnixFileHandle>().fd;
 	return GetFileTypeInternal(fd);
 }
 
 void LocalFileSystem::Truncate(FileHandle &handle, int64_t new_size) {
-	int fd = ((UnixFileHandle &)handle).fd;
+	int fd = handle.Cast<UnixFileHandle>().fd;
 	if (ftruncate(fd, new_size) != 0) {
 		throw IOException("Could not truncate file \"%s\": %s", handle.path, strerror(errno));
 	}
@@ -444,7 +444,7 @@ bool LocalFileSystem::ListFiles(const string &directory, const std::function<voi
 }
 
 void LocalFileSystem::FileSync(FileHandle &handle) {
-	int fd = ((UnixFileHandle &)handle).fd;
+	int fd = handle.Cast<UnixFileHandle>().fd;
 	if (fsync(fd) != 0) {
 		throw FatalException("fsync failed!");
 	}

package/src/duckdb/src/common/operator/cast_operators.cpp

@@ -1460,7 +1460,7 @@ bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_v
 	}
 
 	result = StringVector::EmptyString(result_vector, result_size);
-	Blob::ToBlob(input, (data_ptr_t)result.GetDataWriteable());
+	Blob::ToBlob(input, data_ptr_cast(result.GetDataWriteable()));
 	result.Finalize();
 	return true;
 }

package/src/duckdb/src/common/pipe_file_system.cpp

@@ -33,12 +33,12 @@ void PipeFileSystem::Reset(FileHandle &handle) {
 }
 
 int64_t PipeFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &pipe = (PipeFile &)handle;
+	auto &pipe = handle.Cast<PipeFile>();
 	return pipe.ReadChunk(buffer, nr_bytes);
 }
 
 int64_t PipeFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &pipe = (PipeFile &)handle;
+	auto &pipe = handle.Cast<PipeFile>();
 	return pipe.WriteChunk(buffer, nr_bytes);
 }
 

package/src/duckdb/src/common/radix_partitioning.cpp

@@ -219,8 +219,8 @@ void RadixPartitionedTupleData::RepartitionFinalizeStates(PartitionedTupleData &
                                                           idx_t finished_partition_idx) const {
 	D_ASSERT(old_partitioned_data.GetType() == PartitionedTupleDataType::RADIX &&
 	         new_partitioned_data.GetType() == PartitionedTupleDataType::RADIX);
-	const auto &old_radix_partitions = (RadixPartitionedTupleData &)old_partitioned_data;
-	const auto &new_radix_partitions = (RadixPartitionedTupleData &)new_partitioned_data;
+	const auto &old_radix_partitions = old_partitioned_data.Cast<RadixPartitionedTupleData>();
+	const auto &new_radix_partitions = new_partitioned_data.Cast<RadixPartitionedTupleData>();
 	const auto old_radix_bits = old_radix_partitions.GetRadixBits();
 	const auto new_radix_bits = new_radix_partitions.GetRadixBits();
 	D_ASSERT(new_radix_bits > old_radix_bits);

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

@@ -29,7 +29,7 @@ static void HeapGatherStringVector(Vector &v, const idx_t vcount, const Selectio
 		}
 		auto len = Load<uint32_t>(key_locations[i]);
 		key_locations[i] += sizeof(uint32_t);
-		target[col_idx] = StringVector::AddStringOrBlob(v, string_t((const char *)key_locations[i], len));
+		target[col_idx] = StringVector::AddStringOrBlob(v, string_t(const_char_ptr_cast(key_locations[i]), len));
 		key_locations[i] += len;
 	}
 }

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

@@ -8,7 +8,7 @@ using ValidityBytes = TemplatedValidityMask<uint8_t>;
 
 static void ComputeStringEntrySizes(UnifiedVectorFormat &vdata, idx_t entry_sizes[], const idx_t ser_count,
                                     const SelectionVector &sel, const idx_t offset) {
-	auto strings = (string_t *)vdata.data;
+	auto strings = UnifiedVectorFormat::GetData<string_t>(vdata);
 	for (idx_t i = 0; i < ser_count; i++) {
 		auto idx = sel.get_index(i);
 		auto str_idx = vdata.sel->get_index(idx + offset);
@@ -116,14 +116,14 @@ void RowOperations::ComputeEntrySizes(Vector &v, idx_t entry_sizes[], idx_t vcou
 template <class T>
 static void TemplatedHeapScatter(UnifiedVectorFormat &vdata, const SelectionVector &sel, idx_t count, idx_t col_idx,
                                  data_ptr_t *key_locations, data_ptr_t *validitymask_locations, idx_t offset) {
-	auto source = (T *)vdata.data;
+	auto source = UnifiedVectorFormat::GetData<T>(vdata);
 	if (!validitymask_locations) {
 		for (idx_t i = 0; i < count; i++) {
 			auto idx = sel.get_index(i);
 			auto source_idx = vdata.sel->get_index(idx + offset);
 
 			auto target = (T *)key_locations[i];
-			Store<T>(source[source_idx], (data_ptr_t)target);
+			Store<T>(source[source_idx], data_ptr_cast(target));
 			key_locations[i] += sizeof(T);
 		}
 	} else {
@@ -136,7 +136,7 @@ static void TemplatedHeapScatter(UnifiedVectorFormat &vdata, const SelectionVect
 			auto source_idx = vdata.sel->get_index(idx + offset);
 
 			auto target = (T *)key_locations[i];
-			Store<T>(source[source_idx], (data_ptr_t)target);
+			Store<T>(source[source_idx], data_ptr_cast(target));
 			key_locations[i] += sizeof(T);
 
 			// set the validitymask
@@ -152,7 +152,7 @@ static void HeapScatterStringVector(Vector &v, idx_t vcount, const SelectionVect
 	UnifiedVectorFormat vdata;
 	v.ToUnifiedFormat(vcount, vdata);
 
-	auto strings = (string_t *)vdata.data;
+	auto strings = UnifiedVectorFormat::GetData<string_t>(vdata);
 	if (!validitymask_locations) {
 		for (idx_t i = 0; i < ser_count; i++) {
 			auto idx = sel.get_index(i);

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

@@ -64,7 +64,7 @@ static void TemplatedMatchType(UnifiedVectorFormat &col, Vector &rows, Selection
 	idx_t idx_in_entry;
 	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
 
-	auto data = (T *)col.data;
+	auto data = UnifiedVectorFormat::GetData<T>(col);
 	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
 	idx_t match_count = 0;
 	if (!col.validity.AllValid()) {

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,