duckdb 0.8.1-dev0.0 → 0.8.1-dev125.0

package/src/duckdb/src/common/crypto/md5.cpp

@@ -30,7 +30,7 @@ static void ByteReverse(unsigned char *buf, unsigned longs) {
 	uint32_t t;
 	do {
 		t = (uint32_t)((unsigned)buf[3] << 8 | buf[2]) << 16 | ((unsigned)buf[1] << 8 | buf[0]);
-		*(uint32_t *)buf = t;
+		*reinterpret_cast<uint32_t *>(buf) = t;
 		buf += 4;
 	} while (--longs);
 }
@@ -174,7 +174,7 @@ void MD5Context::MD5Update(const_data_ptr_t input, idx_t len) {
 		}
 		memcpy(p, input, t);
 		ByteReverse(in, 16);
-		MD5Transform(buf, (uint32_t *)in);
+		MD5Transform(buf, reinterpret_cast<uint32_t *>(in));
 		input += t;
 		len -= t;
 	}
@@ -184,7 +184,7 @@ void MD5Context::MD5Update(const_data_ptr_t input, idx_t len) {
 	while (len >= 64) {
 		memcpy(in, input, 64);
 		ByteReverse(in, 16);
-		MD5Transform(buf, (uint32_t *)in);
+		MD5Transform(buf, reinterpret_cast<uint32_t *>(in));
 		input += 64;
 		len -= 64;
 	}
@@ -217,7 +217,7 @@ void MD5Context::Finish(data_ptr_t out_digest) {
 		/* Two lots of padding:  Pad the first block to 64 bytes */
 		memset(p, 0, count);
 		ByteReverse(in, 16);
-		MD5Transform(buf, (uint32_t *)in);
+		MD5Transform(buf, reinterpret_cast<uint32_t *>(in));
 
 		/* Now fill the next block with 56 bytes */
 		memset(in, 0, 56);
@@ -228,11 +228,11 @@ void MD5Context::Finish(data_ptr_t out_digest) {
 	ByteReverse(in, 14);
 
 	/* Append length in bits and transform */
-	((uint32_t *)in)[14] = bits[0];
-	((uint32_t *)in)[15] = bits[1];
+	(reinterpret_cast<uint32_t *>(in))[14] = bits[0];
+	(reinterpret_cast<uint32_t *>(in))[15] = bits[1];
 
-	MD5Transform(buf, (uint32_t *)in);
-	ByteReverse((unsigned char *)buf, 4);
+	MD5Transform(buf, reinterpret_cast<uint32_t *>(in));
+	ByteReverse(reinterpret_cast<unsigned char *>(buf), 4);
 	memcpy(out_digest, buf, 16);
 }
 
@@ -260,7 +260,7 @@ string MD5Context::FinishHex() {
 }
 
 void MD5Context::Add(const char *data) {
-	MD5Update((const_data_ptr_t)data, strlen(data));
+	MD5Update(const_data_ptr_cast(data), strlen(data));
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/exception.cpp

@@ -73,8 +73,11 @@ string Exception::ConstructMessageRecursive(const string &msg, std::vector<Excep
 		parameter_count++;
 	}
 	if (parameter_count != values.size()) {
-		throw InternalException("Expected %d parameters, received %d", parameter_count, values.size());
+		throw InternalException("Primary exception: %s\nSecondary exception in ConstructMessageRecursive: Expected %d "
+		                        "parameters, received %d",
+		                        msg.c_str(), parameter_count, values.size());
 	}
+
 #endif
 	return ExceptionFormatValue::Format(msg, values);
 }

package/src/duckdb/src/common/exception_format_value.cpp

@@ -68,22 +68,27 @@ ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(hugeint_t value) {
 }
 
 string ExceptionFormatValue::Format(const string &msg, std::vector<ExceptionFormatValue> &values) {
-	std::vector<duckdb_fmt::basic_format_arg<duckdb_fmt::printf_context>> format_args;
-	for (auto &val : values) {
-		switch (val.type) {
-		case ExceptionFormatValueType::FORMAT_VALUE_TYPE_DOUBLE:
-			format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.dbl_val));
-			break;
-		case ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER:
-			format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.int_val));
-			break;
-		case ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING:
-			format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.str_val));
-			break;
+	try {
+		std::vector<duckdb_fmt::basic_format_arg<duckdb_fmt::printf_context>> format_args;
+		for (auto &val : values) {
+			switch (val.type) {
+			case ExceptionFormatValueType::FORMAT_VALUE_TYPE_DOUBLE:
+				format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.dbl_val));
+				break;
+			case ExceptionFormatValueType::FORMAT_VALUE_TYPE_INTEGER:
+				format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.int_val));
+				break;
+			case ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING:
+				format_args.push_back(duckdb_fmt::internal::make_arg<duckdb_fmt::printf_context>(val.str_val));
+				break;
+			}
 		}
+		return duckdb_fmt::vsprintf(msg, duckdb_fmt::basic_format_args<duckdb_fmt::printf_context>(
+		                                     format_args.data(), static_cast<int>(format_args.size())));
+	} catch (std::exception &ex) {
+		throw InternalException(std::string("Primary exception: ") + msg +
+		                        "\nSecondary exception in ExceptionFormatValue: " + ex.what());
 	}
-	return duckdb_fmt::vsprintf(msg, duckdb_fmt::basic_format_args<duckdb_fmt::printf_context>(
-	                                     format_args.data(), static_cast<int>(format_args.size())));
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/field_writer.cpp

@@ -29,7 +29,7 @@ template <>
 void FieldWriter::Write(const string &val) {
 	Write<uint32_t>((uint32_t)val.size());
 	if (!val.empty()) {
-		WriteData((const_data_ptr_t)val.c_str(), val.size());
+		WriteData(const_data_ptr_cast(val.c_str()), val.size());
 	}
 }
 

package/src/duckdb/src/common/file_system.cpp

@@ -114,9 +114,22 @@ string FileSystem::GetEnvVariable(const string &env) {
 	return WindowsUtil::UnicodeToUTF8(res_w);
 }
 
+static bool StartsWithSingleBackslash(const string &path) {
+	if (path.size() < 2) {
+		return false;
+	}
+	if (path[0] != '/' && path[0] != '\\') {
+		return false;
+	}
+	if (path[1] == '/' || path[1] == '\\') {
+		return false;
+	}
+	return true;
+}
+
 bool FileSystem::IsPathAbsolute(const string &path) {
 	// 1) A single backslash or forward-slash
-	if (PathMatched(path, "\\") || PathMatched(path, "/")) {
+	if (StartsWithSingleBackslash(path)) {
 		return true;
 	}
 	// 2) A disk designator with a backslash (e.g., C:\ or C:/)
@@ -131,7 +144,7 @@ bool FileSystem::IsPathAbsolute(const string &path) {
 string FileSystem::NormalizeAbsolutePath(const string &path) {
 	D_ASSERT(IsPathAbsolute(path));
 	auto result = StringUtil::Lower(FileSystem::ConvertSeparators(path));
-	if (PathMatched(result, "\\")) {
+	if (StartsWithSingleBackslash(result)) {
 		// Path starts with a single backslash or forward slash
 		// prepend drive letter
 		return GetWorkingDirectory().substr(0, 2) + result;

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;
 	}