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

package/src/duckdb/extension/parquet/parquet_reader.cpp

@@ -58,7 +58,7 @@ static shared_ptr<ParquetFileMetadataCache> LoadMetadata(Allocator &allocator, F
 	auto current_time = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
 
 	auto proto = CreateThriftProtocol(allocator, file_handle, false);
-	auto &transport = ((ThriftFileTransport &)*proto->getTransport());
+	auto &transport = reinterpret_cast<ThriftFileTransport &>(*proto->getTransport());
 	auto file_size = transport.GetSize();
 	if (file_size < 12) {
 		throw InvalidInputException("File '%s' too small to be a Parquet file", file_handle.path);
@@ -71,11 +71,11 @@ static shared_ptr<ParquetFileMetadataCache> LoadMetadata(Allocator &allocator, F
 	transport.SetLocation(file_size - 8);
 	transport.read((uint8_t *)buf.ptr, 8);
 
-	if (strncmp(buf.ptr + 4, "PAR1", 4) != 0) {
+	if (memcmp(buf.ptr + 4, "PAR1", 4) != 0) {
 		throw InvalidInputException("No magic bytes found at end of file '%s'", file_handle.path);
 	}
 	// read four-byte footer length from just before the end magic bytes
-	auto footer_len = *(uint32_t *)buf.ptr;
+	auto footer_len = *reinterpret_cast<uint32_t *>(buf.ptr);
 	if (footer_len <= 0 || file_size < 12 + footer_len) {
 		throw InvalidInputException("Footer length error in file '%s'", file_handle.path);
 	}
@@ -484,7 +484,7 @@ unique_ptr<BaseStatistics> ParquetReader::ReadStatistics(const string &name) {
 	unique_ptr<BaseStatistics> column_stats;
 	auto file_meta_data = GetFileMetadata();
 	auto root_reader = CreateReader();
-	auto column_reader = ((StructColumnReader *)root_reader.get())->GetChildReader(file_col_idx);
+	auto column_reader = root_reader->Cast<StructColumnReader>().GetChildReader(file_col_idx);
 
 	for (idx_t row_group_idx = 0; row_group_idx < file_meta_data->row_groups.size(); row_group_idx++) {
 		auto &row_group = file_meta_data->row_groups[row_group_idx];
@@ -573,7 +573,7 @@ idx_t ParquetReader::GetGroupOffset(ParquetReaderScanState &state) {
 void ParquetReader::PrepareRowGroupBuffer(ParquetReaderScanState &state, idx_t col_idx) {
 	auto &group = GetGroup(state);
 	auto column_id = reader_data.column_ids[col_idx];
-	auto column_reader = ((StructColumnReader *)state.root_reader.get())->GetChildReader(column_id);
+	auto column_reader = state.root_reader->Cast<StructColumnReader>().GetChildReader(column_id);
 
 	// TODO move this to columnreader too
 	if (reader_data.filters) {
@@ -760,14 +760,14 @@ static void FilterOperationSwitch(Vector &v, Value &constant, parquet_filter_t &
 static void ApplyFilter(Vector &v, TableFilter &filter, parquet_filter_t &filter_mask, idx_t count) {
 	switch (filter.filter_type) {
 	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction = (ConjunctionAndFilter &)filter;
+		auto &conjunction = filter.Cast<ConjunctionAndFilter>();
 		for (auto &child_filter : conjunction.child_filters) {
 			ApplyFilter(v, *child_filter, filter_mask, count);
 		}
 		break;
 	}
 	case TableFilterType::CONJUNCTION_OR: {
-		auto &conjunction = (ConjunctionOrFilter &)filter;
+		auto &conjunction = filter.Cast<ConjunctionOrFilter>();
 		parquet_filter_t or_mask;
 		for (auto &child_filter : conjunction.child_filters) {
 			parquet_filter_t child_mask = filter_mask;
@@ -778,7 +778,7 @@ static void ApplyFilter(Vector &v, TableFilter &filter, parquet_filter_t &filter
 		break;
 	}
 	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = (ConstantFilter &)filter;
+		auto &constant_filter = filter.Cast<ConstantFilter>();
 		switch (constant_filter.comparison_type) {
 		case ExpressionType::COMPARE_EQUAL:
 			FilterOperationSwitch<Equals>(v, constant_filter.constant, filter_mask, count);
@@ -831,7 +831,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 		state.current_group++;
 		state.group_offset = 0;
 
-		auto &trans = (ThriftFileTransport &)*state.thrift_file_proto->getTransport();
+		auto &trans = reinterpret_cast<ThriftFileTransport &>(*state.thrift_file_proto->getTransport());
 		trans.ClearPrefetch();
 		state.current_group_prefetched = false;
 
@@ -846,8 +846,8 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 
 			auto file_col_idx = reader_data.column_ids[col_idx];
 
-			auto root_reader = ((StructColumnReader *)state.root_reader.get());
-			to_scan_compressed_bytes += root_reader->GetChildReader(file_col_idx)->TotalCompressedSize();
+			auto &root_reader = state.root_reader->Cast<StructColumnReader>();
+			to_scan_compressed_bytes += root_reader.GetChildReader(file_col_idx)->TotalCompressedSize();
 		}
 
 		auto &group = GetGroup(state);
@@ -880,14 +880,14 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 				// Prefetch column-wise
 				for (idx_t col_idx = 0; col_idx < reader_data.column_ids.size(); col_idx++) {
 					auto file_col_idx = reader_data.column_ids[col_idx];
-					auto root_reader = ((StructColumnReader *)state.root_reader.get());
+					auto &root_reader = state.root_reader->Cast<StructColumnReader>();
 
 					bool has_filter = false;
 					if (reader_data.filters) {
 						auto entry = reader_data.filters->filters.find(reader_data.column_mapping[col_idx]);
 						has_filter = entry != reader_data.filters->filters.end();
 					}
-					root_reader->GetChildReader(file_col_idx)->RegisterPrefetch(trans, !(lazy_fetch && !has_filter));
+					root_reader.GetChildReader(file_col_idx)->RegisterPrefetch(trans, !(lazy_fetch && !has_filter));
 				}
 
 				trans.FinalizeRegistration();
@@ -924,7 +924,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 	auto define_ptr = (uint8_t *)state.define_buf.ptr;
 	auto repeat_ptr = (uint8_t *)state.repeat_buf.ptr;
 
-	auto root_reader = ((StructColumnReader *)state.root_reader.get());
+	auto &root_reader = state.root_reader->Cast<StructColumnReader>();
 
 	if (reader_data.filters) {
 		vector<bool> need_to_read(reader_data.column_ids.size(), true);
@@ -947,7 +947,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 				auto result_idx = reader_data.column_mapping[id];
 
 				auto &result_vector = result.data[result_idx];
-				auto child_reader = root_reader->GetChildReader(file_col_idx);
+				auto child_reader = root_reader.GetChildReader(file_col_idx);
 				child_reader->Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
 				need_to_read[id] = false;
 
@@ -962,11 +962,11 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 			}
 			auto file_col_idx = reader_data.column_ids[col_idx];
 			if (filter_mask.none()) {
-				root_reader->GetChildReader(file_col_idx)->Skip(result.size());
+				root_reader.GetChildReader(file_col_idx)->Skip(result.size());
 				continue;
 			}
 			auto &result_vector = result.data[reader_data.column_mapping[col_idx]];
-			auto child_reader = root_reader->GetChildReader(file_col_idx);
+			auto child_reader = root_reader.GetChildReader(file_col_idx);
 			child_reader->Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
 		}
 
@@ -982,7 +982,7 @@ bool ParquetReader::ScanInternal(ParquetReaderScanState &state, DataChunk &resul
 		for (idx_t col_idx = 0; col_idx < reader_data.column_ids.size(); col_idx++) {
 			auto file_col_idx = reader_data.column_ids[col_idx];
 			auto &result_vector = result.data[reader_data.column_mapping[col_idx]];
-			auto child_reader = root_reader->GetChildReader(file_col_idx);
+			auto child_reader = root_reader.GetChildReader(file_col_idx);
 			auto rows_read = child_reader->Read(result.size(), filter_mask, define_ptr, repeat_ptr, result_vector);
 			if (rows_read != result.size()) {
 				throw InvalidInputException("Mismatch in parquet read for column %llu, expected %llu rows, got %llu",

package/src/duckdb/extension/parquet/parquet_statistics.cpp

@@ -48,12 +48,13 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 	if (stats.empty()) {
 		return Value();
 	}
+	auto stats_data = const_data_ptr_cast(stats.c_str());
 	switch (type.id()) {
 	case LogicalTypeId::BOOLEAN: {
 		if (stats.size() != sizeof(bool)) {
 			throw InternalException("Incorrect stats size for type BOOLEAN");
 		}
-		return Value::BOOLEAN(Load<bool>((data_ptr_t)stats.c_str()));
+		return Value::BOOLEAN(Load<bool>(stats_data));
 	}
 	case LogicalTypeId::UTINYINT:
 	case LogicalTypeId::USMALLINT:
@@ -61,29 +62,29 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 		if (stats.size() != sizeof(uint32_t)) {
 			throw InternalException("Incorrect stats size for type UINTEGER");
 		}
-		return Value::UINTEGER(Load<uint32_t>((data_ptr_t)stats.c_str()));
+		return Value::UINTEGER(Load<uint32_t>(stats_data));
 	case LogicalTypeId::UBIGINT:
 		if (stats.size() != sizeof(uint64_t)) {
 			throw InternalException("Incorrect stats size for type UBIGINT");
 		}
-		return Value::UBIGINT(Load<uint64_t>((data_ptr_t)stats.c_str()));
+		return Value::UBIGINT(Load<uint64_t>(stats_data));
 	case LogicalTypeId::TINYINT:
 	case LogicalTypeId::SMALLINT:
 	case LogicalTypeId::INTEGER:
 		if (stats.size() != sizeof(int32_t)) {
 			throw InternalException("Incorrect stats size for type INTEGER");
 		}
-		return Value::INTEGER(Load<int32_t>((data_ptr_t)stats.c_str()));
+		return Value::INTEGER(Load<int32_t>(stats_data));
 	case LogicalTypeId::BIGINT:
 		if (stats.size() != sizeof(int64_t)) {
 			throw InternalException("Incorrect stats size for type BIGINT");
 		}
-		return Value::BIGINT(Load<int64_t>((data_ptr_t)stats.c_str()));
+		return Value::BIGINT(Load<int64_t>(stats_data));
 	case LogicalTypeId::FLOAT: {
 		if (stats.size() != sizeof(float)) {
 			throw InternalException("Incorrect stats size for type FLOAT");
 		}
-		auto val = Load<float>((data_ptr_t)stats.c_str());
+		auto val = Load<float>(stats_data);
 		if (!Value::FloatIsFinite(val)) {
 			return Value();
 		}
@@ -93,7 +94,7 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 		if (stats.size() != sizeof(double)) {
 			throw InternalException("Incorrect stats size for type DOUBLE");
 		}
-		auto val = Load<double>((data_ptr_t)stats.c_str());
+		auto val = Load<double>(stats_data);
 		if (!Value::DoubleIsFinite(val)) {
 			return Value();
 		}
@@ -107,13 +108,13 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 			if (stats.size() != sizeof(int32_t)) {
 				throw InternalException("Incorrect stats size for type %s", type.ToString());
 			}
-			return Value::DECIMAL(Load<int32_t>((data_ptr_t)stats.c_str()), width, scale);
+			return Value::DECIMAL(Load<int32_t>(stats_data), width, scale);
 		}
 		case Type::INT64: {
 			if (stats.size() != sizeof(int64_t)) {
 				throw InternalException("Incorrect stats size for type %s", type.ToString());
 			}
-			return Value::DECIMAL(Load<int64_t>((data_ptr_t)stats.c_str()), width, scale);
+			return Value::DECIMAL(Load<int64_t>(stats_data), width, scale);
 		}
 		case Type::BYTE_ARRAY:
 		case Type::FIXED_LEN_BYTE_ARRAY:
@@ -122,21 +123,17 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 			}
 			switch (type.InternalType()) {
 			case PhysicalType::INT16:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<int16_t>((const_data_ptr_t)stats.c_str(), stats.size()),
-				    width, scale);
+				return Value::DECIMAL(ParquetDecimalUtils::ReadDecimalValue<int16_t>(stats_data, stats.size()), width,
+				                      scale);
 			case PhysicalType::INT32:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<int32_t>((const_data_ptr_t)stats.c_str(), stats.size()),
-				    width, scale);
+				return Value::DECIMAL(ParquetDecimalUtils::ReadDecimalValue<int32_t>(stats_data, stats.size()), width,
+				                      scale);
 			case PhysicalType::INT64:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<int64_t>((const_data_ptr_t)stats.c_str(), stats.size()),
-				    width, scale);
+				return Value::DECIMAL(ParquetDecimalUtils::ReadDecimalValue<int64_t>(stats_data, stats.size()), width,
+				                      scale);
 			case PhysicalType::INT128:
-				return Value::DECIMAL(
-				    ParquetDecimalUtils::ReadDecimalValue<hugeint_t>((const_data_ptr_t)stats.c_str(), stats.size()),
-				    width, scale);
+				return Value::DECIMAL(ParquetDecimalUtils::ReadDecimalValue<hugeint_t>(stats_data, stats.size()), width,
+				                      scale);
 			default:
 				throw InternalException("Unsupported internal type for decimal");
 			}
@@ -155,14 +152,14 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 		if (stats.size() != sizeof(int32_t)) {
 			throw InternalException("Incorrect stats size for type DATE");
 		}
-		return Value::DATE(date_t(Load<int32_t>((data_ptr_t)stats.c_str())));
+		return Value::DATE(date_t(Load<int32_t>(stats_data)));
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIME_TZ: {
 		int64_t val;
 		if (stats.size() == sizeof(int32_t)) {
-			val = Load<int32_t>((data_ptr_t)stats.c_str());
+			val = Load<int32_t>(stats_data);
 		} else if (stats.size() == sizeof(int64_t)) {
-			val = Load<int64_t>((data_ptr_t)stats.c_str());
+			val = Load<int64_t>(stats_data);
 		} else {
 			throw InternalException("Incorrect stats size for type TIME");
 		}
@@ -190,13 +187,13 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 			if (stats.size() != sizeof(Int96)) {
 				throw InternalException("Incorrect stats size for type TIMESTAMP");
 			}
-			return Value::TIMESTAMP(ImpalaTimestampToTimestamp(Load<Int96>((data_ptr_t)stats.c_str())));
+			return Value::TIMESTAMP(ImpalaTimestampToTimestamp(Load<Int96>(stats_data)));
 		} else {
 			D_ASSERT(schema_ele.type == Type::INT64);
 			if (stats.size() != sizeof(int64_t)) {
 				throw InternalException("Incorrect stats size for type TIMESTAMP");
 			}
-			auto val = Load<int64_t>((data_ptr_t)stats.c_str());
+			auto val = Load<int64_t>(stats_data);
 			if (schema_ele.__isset.logicalType && schema_ele.logicalType.__isset.TIMESTAMP) {
 				// logical type
 				if (schema_ele.logicalType.TIMESTAMP.unit.__isset.MILLIS) {

package/src/duckdb/extension/parquet/parquet_timestamp.cpp

@@ -17,7 +17,7 @@ static constexpr int64_t NANOSECONDS_PER_MICRO = 1000LL;
 
 static int64_t ImpalaTimestampToMicroseconds(const Int96 &impala_timestamp) {
 	int64_t days_since_epoch = impala_timestamp.value[2] - JULIAN_TO_UNIX_EPOCH_DAYS;
-	auto nanoseconds = Load<int64_t>((data_ptr_t)impala_timestamp.value);
+	auto nanoseconds = Load<int64_t>(const_data_ptr_cast(impala_timestamp.value));
 	auto microseconds = nanoseconds / NANOSECONDS_PER_MICRO;
 	return days_since_epoch * MICROSECONDS_PER_DAY + microseconds;
 }
@@ -35,7 +35,7 @@ Int96 TimestampToImpalaTimestamp(timestamp_t &ts) {
 	// first two uint32 in Int96 are nanoseconds since midnights
 	// last uint32 is number of days since year 4713 BC ("Julian date")
 	Int96 impala_ts;
-	Store<uint64_t>(ms_since_midnight * 1000000, (data_ptr_t)impala_ts.value);
+	Store<uint64_t>(ms_since_midnight * 1000000, data_ptr_cast(impala_ts.value));
 	impala_ts.value[2] = days_since_epoch + JULIAN_TO_UNIX_EPOCH_DAYS;
 	return impala_ts;
 }

package/src/duckdb/extension/parquet/parquet_writer.cpp

@@ -45,7 +45,7 @@ public:
 	}
 
 	void write_virt(const uint8_t *buf, uint32_t len) override {
-		serializer.WriteData((const_data_ptr_t)buf, len);
+		serializer.WriteData(const_data_ptr_cast(buf), len);
 	}
 
 private:
@@ -232,7 +232,7 @@ ParquetWriter::ParquetWriter(FileSystem &fs, string file_name_p, vector<LogicalT
 	writer = make_uniq<BufferedFileWriter>(fs, file_name.c_str(),
 	                                       FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW);
 	// parquet files start with the string "PAR1"
-	writer->WriteData((const_data_ptr_t) "PAR1", 4);
+	writer->WriteData(const_data_ptr_cast("PAR1"), 4);
 	TCompactProtocolFactoryT<MyTransport> tproto_factory;
 	protocol = tproto_factory.getProtocol(make_shared<MyTransport>(*writer));
 
@@ -327,7 +327,7 @@ void ParquetWriter::Finalize() {
 	writer->Write<uint32_t>(writer->GetTotalWritten() - start_offset);
 
 	// parquet files also end with the string "PAR1"
-	writer->WriteData((const_data_ptr_t) "PAR1", 4);
+	writer->WriteData(const_data_ptr_cast("PAR1"), 4);
 
 	// flush to disk
 	writer->Sync();

package/src/duckdb/extension/parquet/zstd_file_system.cpp

@@ -61,9 +61,9 @@ bool ZstdStreamWrapper::Read(StreamData &sd) {
 		throw IOException(duckdb_zstd::ZSTD_getErrorName(res));
 	}
 
-	sd.in_buff_start = (data_ptr_t)in_buffer.src + in_buffer.pos;
-	sd.in_buff_end = (data_ptr_t)in_buffer.src + in_buffer.size;
-	sd.out_buff_end = (data_ptr_t)out_buffer.dst + out_buffer.pos;
+	sd.in_buff_start = (data_ptr_t)in_buffer.src + in_buffer.pos;  // NOLINT
+	sd.in_buff_end = (data_ptr_t)in_buffer.src + in_buffer.size;   // NOLINT
+	sd.out_buff_end = (data_ptr_t)out_buffer.dst + out_buffer.pos; // NOLINT
 	return false;
 }
 

package/src/duckdb/src/catalog/catalog_set.cpp

@@ -42,7 +42,7 @@ private:
 };
 
 CatalogSet::CatalogSet(Catalog &catalog_p, unique_ptr<DefaultGenerator> defaults)
-    : catalog((DuckCatalog &)catalog_p), defaults(std::move(defaults)) {
+    : catalog(catalog_p.Cast<DuckCatalog>()), defaults(std::move(defaults)) {
 	D_ASSERT(catalog_p.IsDuckCatalog());
 }
 CatalogSet::~CatalogSet() {

package/src/duckdb/src/catalog/dependency_manager.cpp

@@ -220,8 +220,8 @@ void DependencyManager::AddOwnership(CatalogTransaction transaction, CatalogEntr
 	// Emplace guarantees that the same object cannot be inserted twice in the unordered_set
 	// In the case AddOwnership is called twice, because of emplace, the object will not be repeated in the set.
 	// We use an automatic dependency because if the Owner gets deleted, then the owned objects are also deleted
-	dependents_map[owner].emplace(Dependency(entry, DependencyType::DEPENDENCY_OWNS));
-	dependents_map[entry].emplace(Dependency(owner, DependencyType::DEPENDENCY_OWNED_BY));
+	dependents_map[owner].emplace(entry, DependencyType::DEPENDENCY_OWNS);
+	dependents_map[entry].emplace(owner, DependencyType::DEPENDENCY_OWNED_BY);
 	dependencies_map[owner].emplace(entry);
 }
 

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