duckdb 0.8.1-dev2.0 → 0.8.1-dev219.0

package/src/duckdb/src/common/arrow/arrow_appender.cpp

@@ -162,8 +162,8 @@ struct ArrowScalarBaseData {
 
 		// append the main data
 		append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(TGT) * size);
-		auto data = (SRC *)format.data;
-		auto result_data = (TGT *)append_data.main_buffer.data();
+		auto data = UnifiedVectorFormat::GetData<SRC>(format);
+		auto result_data = append_data.main_buffer.GetData<TGT>();
 
 		for (idx_t i = from; i < to; i++) {
 			auto source_idx = format.sel->get_index(i);
@@ -210,8 +210,8 @@ struct ArrowEnumData : public ArrowScalarBaseData<TGT> {
 
 		// resize the offset buffer - the offset buffer holds the offsets into the child array
 		append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(uint32_t) * (size + 1));
-		auto data = (string_t *)FlatVector::GetData<string_t>(input);
-		auto offset_data = (uint32_t *)append_data.main_buffer.data();
+		auto data = FlatVector::GetData<string_t>(input);
+		auto offset_data = append_data.main_buffer.GetData<uint32_t>();
 		if (append_data.row_count == 0) {
 			// first entry
 			offset_data[0] = 0;
@@ -269,10 +269,10 @@ struct ArrowBoolData {
 		// we initialize both the validity and the bit set to 1's
 		ResizeValidity(append_data.validity, append_data.row_count + size);
 		ResizeValidity(append_data.main_buffer, append_data.row_count + size);
-		auto data = (bool *)format.data;
+		auto data = UnifiedVectorFormat::GetData<bool>(format);
 
-		auto result_data = (uint8_t *)append_data.main_buffer.data();
-		auto validity_data = (uint8_t *)append_data.validity.data();
+		auto result_data = append_data.main_buffer.GetData<uint8_t>();
+		auto validity_data = append_data.validity.GetData<uint8_t>();
 		uint8_t current_bit;
 		idx_t current_byte;
 		GetBitPosition(append_data.row_count, current_byte, current_bit);
@@ -318,7 +318,7 @@ struct ArrowUUIDConverter {
 
 	template <class SRC>
 	static void WriteData(data_ptr_t target, SRC input) {
-		UUID::ToString(input, (char *)target);
+		UUID::ToString(input, char_ptr_cast(target));
 	}
 };
 
@@ -341,8 +341,8 @@ struct ArrowVarcharData {
 
 		// resize the offset buffer - the offset buffer holds the offsets into the child array
 		append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(BUFTYPE) * (size + 1));
-		auto data = (SRC *)format.data;
-		auto offset_data = (BUFTYPE *)append_data.main_buffer.data();
+		auto data = UnifiedVectorFormat::GetData<SRC>(format);
+		auto offset_data = append_data.main_buffer.GetData<BUFTYPE>();
 		if (append_data.row_count == 0) {
 			// first entry
 			offset_data[0] = 0;
@@ -441,8 +441,8 @@ void AppendListOffsets(ArrowAppendData &append_data, UnifiedVectorFormat &format
 	// resize the offset buffer - the offset buffer holds the offsets into the child array
 	idx_t size = to - from;
 	append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(uint32_t) * (size + 1));
-	auto data = (list_entry_t *)format.data;
-	auto offset_data = (uint32_t *)append_data.main_buffer.data();
+	auto data = UnifiedVectorFormat::GetData<list_entry_t>(format);
+	auto offset_data = append_data.main_buffer.GetData<uint32_t>();
 	if (append_data.row_count == 0) {
 		// first entry
 		offset_data[0] = 0;

package/src/duckdb/src/common/arrow/arrow_wrapper.cpp

@@ -77,7 +77,7 @@ int ResultArrowArrayStreamWrapper::MyStreamGetSchema(struct ArrowArrayStream *st
 	if (!stream->release) {
 		return -1;
 	}
-	auto my_stream = (ResultArrowArrayStreamWrapper *)stream->private_data;
+	auto my_stream = reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
 	if (!my_stream->column_types.empty()) {
 		ArrowConverter::ToArrowSchema(out, my_stream->column_types, my_stream->column_names,
 		                              my_stream->timezone_config);
@@ -90,7 +90,7 @@ int ResultArrowArrayStreamWrapper::MyStreamGetSchema(struct ArrowArrayStream *st
 		return -1;
 	}
 	if (result.type == QueryResultType::STREAM_RESULT) {
-		auto &stream_result = (StreamQueryResult &)result;
+		auto &stream_result = result.Cast<StreamQueryResult>();
 		if (!stream_result.IsOpen()) {
 			my_stream->last_error = PreservedError("Query Stream is closed");
 			return -1;
@@ -108,14 +108,14 @@ int ResultArrowArrayStreamWrapper::MyStreamGetNext(struct ArrowArrayStream *stre
 	if (!stream->release) {
 		return -1;
 	}
-	auto my_stream = (ResultArrowArrayStreamWrapper *)stream->private_data;
+	auto my_stream = reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
 	auto &result = *my_stream->result;
 	if (result.HasError()) {
 		my_stream->last_error = result.GetErrorObject();
 		return -1;
 	}
 	if (result.type == QueryResultType::STREAM_RESULT) {
-		auto &stream_result = (StreamQueryResult &)result;
+		auto &stream_result = result.Cast<StreamQueryResult>();
 		if (!stream_result.IsOpen()) {
 			// Nothing to output
 			out->release = nullptr;
@@ -145,7 +145,7 @@ void ResultArrowArrayStreamWrapper::MyStreamRelease(struct ArrowArrayStream *str
 		return;
 	}
 	stream->release = nullptr;
-	delete (ResultArrowArrayStreamWrapper *)stream->private_data;
+	delete reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
 }
 
 const char *ResultArrowArrayStreamWrapper::MyStreamGetLastError(struct ArrowArrayStream *stream) {
@@ -153,7 +153,7 @@ const char *ResultArrowArrayStreamWrapper::MyStreamGetLastError(struct ArrowArra
 		return "stream was released";
 	}
 	D_ASSERT(stream->private_data);
-	auto my_stream = (ResultArrowArrayStreamWrapper *)stream->private_data;
+	auto my_stream = reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
 	return my_stream->last_error.Message().c_str();
 }
 
@@ -175,7 +175,7 @@ ResultArrowArrayStreamWrapper::ResultArrowArrayStreamWrapper(unique_ptr<QueryRes
 
 bool ArrowUtil::TryFetchNext(QueryResult &result, unique_ptr<DataChunk> &chunk, PreservedError &error) {
 	if (result.type == QueryResultType::STREAM_RESULT) {
-		auto &stream_result = (StreamQueryResult &)result;
+		auto &stream_result = result.Cast<StreamQueryResult>();
 		if (!stream_result.IsOpen()) {
 			return true;
 		}

package/src/duckdb/src/common/checksum.cpp

@@ -9,7 +9,7 @@ hash_t Checksum(uint64_t x) {
 
 uint64_t Checksum(uint8_t *buffer, size_t size) {
 	uint64_t result = 5381;
-	uint64_t *ptr = (uint64_t *)buffer;
+	uint64_t *ptr = reinterpret_cast<uint64_t *>(buffer);
 	size_t i;
 	// for efficiency, we first checksum uint64_t values
 	for (i = 0; i < size / 8; i++) {

package/src/duckdb/src/common/compressed_file_system.cpp

@@ -115,28 +115,28 @@ void CompressedFile::Close() {
 }
 
 int64_t CompressedFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &compressed_file = (CompressedFile &)handle;
+	auto &compressed_file = handle.Cast<CompressedFile>();
 	return compressed_file.ReadData(buffer, nr_bytes);
 }
 
 int64_t CompressedFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &compressed_file = (CompressedFile &)handle;
-	return compressed_file.WriteData((data_ptr_t)buffer, nr_bytes);
+	auto &compressed_file = handle.Cast<CompressedFile>();
+	return compressed_file.WriteData(data_ptr_cast(buffer), nr_bytes);
 }
 
 void CompressedFileSystem::Reset(FileHandle &handle) {
-	auto &compressed_file = (CompressedFile &)handle;
+	auto &compressed_file = handle.Cast<CompressedFile>();
 	compressed_file.child_handle->Reset();
 	compressed_file.Initialize(compressed_file.write);
 }
 
 int64_t CompressedFileSystem::GetFileSize(FileHandle &handle) {
-	auto &compressed_file = (CompressedFile &)handle;
+	auto &compressed_file = handle.Cast<CompressedFile>();
 	return compressed_file.child_handle->GetFileSize();
 }
 
 bool CompressedFileSystem::OnDiskFile(FileHandle &handle) {
-	auto &compressed_file = (CompressedFile &)handle;
+	auto &compressed_file = handle.Cast<CompressedFile>();
 	return compressed_file.child_handle->OnDiskFile();
 }
 

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()) {