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

package/src/duckdb/src/planner/expression.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/planner/expression/list.hpp"
+#include "duckdb/parser/expression_util.hpp"
 
 namespace duckdb {
 
@@ -165,4 +166,18 @@ unique_ptr<Expression> Expression::Deserialize(Deserializer &source, PlanDeseria
 	return result;
 }
 
+bool Expression::Equals(const unique_ptr<Expression> &left, const unique_ptr<Expression> &right) {
+	if (left.get() == right.get()) {
+		return true;
+	}
+	if (!left || !right) {
+		return false;
+	}
+	return left->Equals(*right);
+}
+
+bool Expression::ListEquals(const vector<unique_ptr<Expression>> &left, const vector<unique_ptr<Expression>> &right) {
+	return ExpressionUtil::ListEquals(left, right);
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/expression_binder/base_select_binder.cpp

@@ -62,8 +62,8 @@ idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
 	}
 #ifdef DEBUG
 	for (auto entry : info.map) {
-		D_ASSERT(!entry.first.get().Equals(&expr));
-		D_ASSERT(!expr.Equals(&entry.first.get()));
+		D_ASSERT(!entry.first.get().Equals(expr));
+		D_ASSERT(!expr.Equals(entry.first.get()));
 	}
 #endif
 	return DConstants::INVALID_INDEX;

package/src/duckdb/src/planner/expression_iterator.cpp

@@ -230,12 +230,12 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 	for (idx_t i = 0; i < node.modifiers.size(); i++) {
 		switch (node.modifiers[i]->type) {
 		case ResultModifierType::DISTINCT_MODIFIER:
-			for (auto &expr : ((BoundDistinctModifier &)*node.modifiers[i]).target_distincts) {
+			for (auto &expr : node.modifiers[i]->Cast<BoundDistinctModifier>().target_distincts) {
 				EnumerateExpression(expr, callback);
 			}
 			break;
 		case ResultModifierType::ORDER_MODIFIER:
-			for (auto &order : ((BoundOrderModifier &)*node.modifiers[i]).orders) {
+			for (auto &order : node.modifiers[i]->Cast<BoundOrderModifier>().orders) {
 				EnumerateExpression(order.expression, callback);
 			}
 			break;

package/src/duckdb/src/planner/filter/conjunction_filter.cpp

@@ -35,7 +35,7 @@ bool ConjunctionOrFilter::Equals(const TableFilter &other_p) const {
 	if (!ConjunctionFilter::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (ConjunctionOrFilter &)other_p;
+	auto &other = other_p.Cast<ConjunctionOrFilter>();
 	if (other.child_filters.size() != child_filters.size()) {
 		return false;
 	}
@@ -90,7 +90,7 @@ bool ConjunctionAndFilter::Equals(const TableFilter &other_p) const {
 	if (!ConjunctionFilter::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (ConjunctionAndFilter &)other_p;
+	auto &other = other_p.Cast<ConjunctionAndFilter>();
 	if (other.child_filters.size() != child_filters.size()) {
 		return false;
 	}

package/src/duckdb/src/planner/filter/constant_filter.cpp

@@ -39,7 +39,7 @@ bool ConstantFilter::Equals(const TableFilter &other_p) const {
 	if (!TableFilter::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (ConstantFilter &)other_p;
+	auto &other = other_p.Cast<ConstantFilter>();
 	return other.comparison_type == comparison_type && other.constant == constant;
 }
 

package/src/duckdb/src/planner/logical_operator.cpp

@@ -109,13 +109,12 @@ void LogicalOperator::Verify(ClientContext &context) {
 		// copy should be identical to original
 		D_ASSERT(expressions[expr_idx]->ToString() == copy->ToString());
 		D_ASSERT(original_hash == copy_hash);
-		D_ASSERT(Expression::Equals(expressions[expr_idx].get(), copy.get()));
+		D_ASSERT(Expression::Equals(expressions[expr_idx], copy));
 
-		D_ASSERT(!Expression::Equals(expressions[expr_idx].get(), nullptr));
 		for (idx_t other_idx = 0; other_idx < expr_idx; other_idx++) {
 			// comparison with other expressions
 			auto other_hash = expressions[other_idx]->Hash();
-			bool expr_equal = Expression::Equals(expressions[expr_idx].get(), expressions[other_idx].get());
+			bool expr_equal = Expression::Equals(expressions[expr_idx], expressions[other_idx]);
 			if (original_hash != other_hash) {
 				// if the hashes are not equal the expressions should not be equal either
 				D_ASSERT(!expr_equal);
@@ -144,7 +143,7 @@ void LogicalOperator::Verify(ClientContext &context) {
 		auto deserialized_expression = Expression::Deserialize(deserializer, state);
 		// FIXME: expressions might not be equal yet because of statistics propagation
 		continue;
-		D_ASSERT(Expression::Equals(expressions[expr_idx].get(), deserialized_expression.get()));
+		D_ASSERT(Expression::Equals(expressions[expr_idx], deserialized_expression));
 		D_ASSERT(expressions[expr_idx]->Hash() == deserialized_expression->Hash());
 	}
 	D_ASSERT(!ToString().empty());

package/src/duckdb/src/planner/logical_operator_visitor.cpp

@@ -97,7 +97,7 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: {
-		auto &limit = (LogicalLimitPercent &)op;
+		auto &limit = op.Cast<LogicalLimitPercent>();
 		if (limit.limit) {
 			callback(&limit.limit);
 		}

package/src/duckdb/src/planner/table_filter.cpp

@@ -14,7 +14,7 @@ void TableFilterSet::PushFilter(idx_t column_index, unique_ptr<TableFilter> filt
 	} else {
 		// there is already a filter: AND it together
 		if (entry->second->filter_type == TableFilterType::CONJUNCTION_AND) {
-			auto &and_filter = (ConjunctionAndFilter &)*entry->second;
+			auto &and_filter = entry->second->Cast<ConjunctionAndFilter>();
 			and_filter.child_filters.push_back(std::move(filter));
 		} else {
 			auto and_filter = make_uniq<ConjunctionAndFilter>();

package/src/duckdb/src/storage/arena_allocator.cpp

@@ -31,7 +31,7 @@ struct ArenaAllocatorData : public PrivateAllocatorData {
 };
 
 static data_ptr_t ArenaAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size) {
-	auto &allocator_data = (ArenaAllocatorData &)*private_data;
+	auto &allocator_data = private_data->Cast<ArenaAllocatorData>();
 	return allocator_data.allocator.Allocate(size);
 }
 
@@ -41,7 +41,7 @@ static void ArenaAllocatorFree(PrivateAllocatorData *, data_ptr_t, idx_t) {
 
 static data_ptr_t ArenaAllocateReallocate(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
                                           idx_t size) {
-	auto &allocator_data = (ArenaAllocatorData &)*private_data;
+	auto &allocator_data = private_data->Cast<ArenaAllocatorData>();
 	return allocator_data.allocator.Reallocate(pointer, old_size, size);
 }
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/storage/buffer/block_handle.cpp

@@ -49,7 +49,7 @@ unique_ptr<Block> AllocateBlock(BlockManager &block_manager, unique_ptr<FileBuff
 		// re-usable buffer: re-use it
 		if (reusable_buffer->type == FileBufferType::BLOCK) {
 			// we can reuse the buffer entirely
-			auto &block = (Block &)*reusable_buffer;
+			auto &block = reinterpret_cast<Block &>(*reusable_buffer);
 			block.id = block_id;
 			return unique_ptr_cast<FileBuffer, Block>(std::move(reusable_buffer));
 		}

package/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp

@@ -33,8 +33,8 @@ void WriteOverflowStringsToDisk::WriteString(string_t string, block_id_t &result
 	size_t compressed_size = 0;
 	compressed_size = s.MaxCompressedLength(uncompressed_size);
 	auto compressed_buf = make_unsafe_uniq_array<data_t>(compressed_size);
-	s.Compress((const char *)string.GetData(), uncompressed_size, (char *)compressed_buf.get(), &compressed_size);
-	string_t compressed_string((const char *)compressed_buf.get(), compressed_size);
+	s.Compress(string.GetData(), uncompressed_size, char_ptr_cast(compressed_buf.get()), &compressed_size);
+	string_t compressed_string(const_char_ptr_cast(compressed_buf.get()), compressed_size);
 
 	// store sizes
 	auto data_ptr = handle.Ptr();

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -41,7 +41,7 @@ SingleFileCheckpointWriter::SingleFileCheckpointWriter(AttachedDatabase &db, Blo
 }
 
 BlockManager &SingleFileCheckpointWriter::GetBlockManager() {
-	auto &storage_manager = (SingleFileStorageManager &)db.GetStorageManager();
+	auto &storage_manager = db.GetStorageManager().Cast<SingleFileStorageManager>();
 	return *storage_manager.block_manager;
 }
 
@@ -55,7 +55,7 @@ unique_ptr<TableDataWriter> SingleFileCheckpointWriter::GetTableDataWriter(Table
 
 void SingleFileCheckpointWriter::CreateCheckpoint() {
 	auto &config = DBConfig::Get(db);
-	auto &storage_manager = (SingleFileStorageManager &)db.GetStorageManager();
+	auto &storage_manager = db.GetStorageManager().Cast<SingleFileStorageManager>();
 	if (storage_manager.InMemory()) {
 		return;
 	}
@@ -73,7 +73,7 @@ void SingleFileCheckpointWriter::CreateCheckpoint() {
 
 	vector<reference<SchemaCatalogEntry>> schemas;
 	// we scan the set of committed schemas
-	auto &catalog = (DuckCatalog &)Catalog::GetCatalog(db);
+	auto &catalog = Catalog::GetCatalog(db).Cast<DuckCatalog>();
 	catalog.ScanSchemas([&](SchemaCatalogEntry &entry) { schemas.push_back(entry); });
 	// write the actual data into the database
 	// write the amount of schemas

package/src/duckdb/src/storage/compression/bitpacking.cpp

@@ -68,7 +68,7 @@ static bitpacking_metadata_encoded_t EncodeMeta(bitpacking_metadata_t metadata)
 }
 static bitpacking_metadata_t DecodeMeta(bitpacking_metadata_encoded_t *metadata_encoded) {
 	bitpacking_metadata_t metadata;
-	metadata.mode = Load<BitpackingMode>((data_ptr_t)(metadata_encoded) + 3);
+	metadata.mode = Load<BitpackingMode>(data_ptr_cast(metadata_encoded) + 3);
 	metadata.offset = *metadata_encoded & 0x00FFFFFF;
 	return metadata;
 }
@@ -324,7 +324,7 @@ bool BitpackingAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
 	UnifiedVectorFormat vdata;
 	input.ToUnifiedFormat(count, vdata);
 
-	auto data = (T *)vdata.data;
+	auto data = UnifiedVectorFormat::GetData<T>(vdata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = vdata.sel->get_index(i);
 		if (!analyze_state.state.template Update<EmptyBitpackingWriter>(data[idx], vdata.validity.RowIsValid(idx))) {
@@ -482,7 +482,7 @@ public:
 	}
 
 	void Append(UnifiedVectorFormat &vdata, idx_t count) {
-		auto data = (T *)vdata.data;
+		auto data = UnifiedVectorFormat::GetData<T>(vdata);
 
 		for (idx_t i = 0; i < count; i++) {
 			auto idx = vdata.sel->get_index(i);
@@ -690,7 +690,7 @@ public:
 					idx_t decompress_offset = current_group_offset - extra_count;
 					bool skip_sign_extension = true;
 
-					BitpackingPrimitives::UnPackBuffer<T>((data_ptr_t)decompression_buffer,
+					BitpackingPrimitives::UnPackBuffer<T>(data_ptr_cast(decompression_buffer),
 					                                      current_group_ptr + decompress_offset, decompress_count,
 					                                      current_width, skip_sign_extension);
 
@@ -795,11 +795,11 @@ void BitpackingScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t
 
 		if (to_scan == BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE && offset_in_compression_group == 0) {
 			// Decompress directly into result vector
-			BitpackingPrimitives::UnPackBlock<T>((data_ptr_t)current_result_ptr, decompression_group_start_pointer,
+			BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(current_result_ptr), decompression_group_start_pointer,
 			                                     scan_state.current_width, skip_sign_extend);
 		} else {
 			// Decompress compression algorithm to buffer
-			BitpackingPrimitives::UnPackBlock<T>((data_ptr_t)scan_state.decompression_buffer,
+			BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(scan_state.decompression_buffer),
 			                                     decompression_group_start_pointer, scan_state.current_width,
 			                                     skip_sign_extend);
 
@@ -860,8 +860,8 @@ void BitpackingFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t r
 	D_ASSERT(scan_state.current_group.mode == BitpackingMode::FOR ||
 	         scan_state.current_group.mode == BitpackingMode::DELTA_FOR);
 
-	BitpackingPrimitives::UnPackBlock<T>((data_ptr_t)scan_state.decompression_buffer, decompression_group_start_pointer,
-	                                     scan_state.current_width, skip_sign_extend);
+	BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(scan_state.decompression_buffer),
+	                                     decompression_group_start_pointer, scan_state.current_width, skip_sign_extend);
 
 	*current_result_ptr = *(T *)(scan_state.decompression_buffer + offset_in_compression_group);
 	*current_result_ptr += scan_state.current_frame_of_reference;

package/src/duckdb/src/storage/compression/dictionary_compression.cpp

@@ -18,7 +18,7 @@ public:
 	bool UpdateState(Vector &scan_vector, idx_t count) {
 		UnifiedVectorFormat vdata;
 		scan_vector.ToUnifiedFormat(count, vdata);
-		auto data = (string_t *)vdata.data;
+		auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
 		Verify();
 
 		for (idx_t i = 0; i < count; i++) {
@@ -274,7 +274,7 @@ public:
 
 		// calculate ptr and offsets
 		auto base_ptr = handle.Ptr();
-		auto header_ptr = (dictionary_compression_header_t *)base_ptr;
+		auto header_ptr = reinterpret_cast<dictionary_compression_header_t *>(base_ptr);
 		auto compressed_selection_buffer_offset = DictionaryCompressionStorage::DICTIONARY_HEADER_SIZE;
 		auto index_buffer_offset = compressed_selection_buffer_offset + compressed_selection_buffer_size;
 
@@ -287,9 +287,9 @@ public:
 		memcpy(base_ptr + index_buffer_offset, index_buffer.data(), index_buffer_size);
 
 		// Store sizes and offsets in segment header
-		Store<uint32_t>(index_buffer_offset, (data_ptr_t)&header_ptr->index_buffer_offset);
-		Store<uint32_t>(index_buffer.size(), (data_ptr_t)&header_ptr->index_buffer_count);
-		Store<uint32_t>((uint32_t)current_width, (data_ptr_t)&header_ptr->bitpacking_width);
+		Store<uint32_t>(index_buffer_offset, data_ptr_cast(&header_ptr->index_buffer_offset));
+		Store<uint32_t>(index_buffer.size(), data_ptr_cast(&header_ptr->index_buffer_count));
+		Store<uint32_t>((uint32_t)current_width, data_ptr_cast(&header_ptr->bitpacking_width));
 
 		D_ASSERT(current_width == BitpackingPrimitives::MinimumBitWidth(index_buffer.size() - 1));
 		D_ASSERT(DictionaryCompressionStorage::HasEnoughSpace(current_segment->count, index_buffer.size(),
@@ -391,12 +391,12 @@ unique_ptr<AnalyzeState> DictionaryCompressionStorage::StringInitAnalyze(ColumnD
 }
 
 bool DictionaryCompressionStorage::StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = (DictionaryCompressionAnalyzeState &)state_p;
+	auto &state = state_p.Cast<DictionaryCompressionAnalyzeState>();
 	return state.analyze_state->UpdateState(input, count);
 }
 
 idx_t DictionaryCompressionStorage::StringFinalAnalyze(AnalyzeState &state_p) {
-	auto &analyze_state = (DictionaryCompressionAnalyzeState &)state_p;
+	auto &analyze_state = state_p.Cast<DictionaryCompressionAnalyzeState>();
 	auto &state = *analyze_state.analyze_state;
 
 	auto width = BitpackingPrimitives::MinimumBitWidth(state.current_unique_count + 1);
@@ -415,12 +415,12 @@ unique_ptr<CompressionState> DictionaryCompressionStorage::InitCompression(Colum
 }
 
 void DictionaryCompressionStorage::Compress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = (DictionaryCompressionCompressState &)state_p;
+	auto &state = state_p.Cast<DictionaryCompressionCompressState>();
 	state.UpdateState(scan_vector, count);
 }
 
 void DictionaryCompressionStorage::FinalizeCompress(CompressionState &state_p) {
-	auto &state = (DictionaryCompressionCompressState &)state_p;
+	auto &state = state_p.Cast<DictionaryCompressionCompressState>();
 	state.Flush(true);
 }
 
@@ -444,12 +444,12 @@ unique_ptr<SegmentScanState> DictionaryCompressionStorage::StringInitScan(Column
 
 	// Load header values
 	auto dict = DictionaryCompressionStorage::GetDictionary(segment, state->handle);
-	auto header_ptr = (dictionary_compression_header_t *)baseptr;
-	auto index_buffer_offset = Load<uint32_t>((data_ptr_t)&header_ptr->index_buffer_offset);
-	auto index_buffer_count = Load<uint32_t>((data_ptr_t)&header_ptr->index_buffer_count);
-	state->current_width = (bitpacking_width_t)(Load<uint32_t>((data_ptr_t)&header_ptr->bitpacking_width));
+	auto header_ptr = reinterpret_cast<dictionary_compression_header_t *>(baseptr);
+	auto index_buffer_offset = Load<uint32_t>(data_ptr_cast(&header_ptr->index_buffer_offset));
+	auto index_buffer_count = Load<uint32_t>(data_ptr_cast(&header_ptr->index_buffer_count));
+	state->current_width = (bitpacking_width_t)(Load<uint32_t>(data_ptr_cast(&header_ptr->bitpacking_width)));
 
-	auto index_buffer_ptr = (uint32_t *)(baseptr + index_buffer_offset);
+	auto index_buffer_ptr = reinterpret_cast<uint32_t *>(baseptr + index_buffer_offset);
 
 	state->dictionary = make_buffer<Vector>(segment.type, index_buffer_count);
 	auto dict_child_data = FlatVector::GetData<string_t>(*(state->dictionary));
@@ -470,17 +470,17 @@ template <bool ALLOW_DICT_VECTORS>
 void DictionaryCompressionStorage::StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
                                                      Vector &result, idx_t result_offset) {
 	// clear any previously locked buffers and get the primary buffer handle
-	auto &scan_state = (CompressedStringScanState &)*state.scan_state;
+	auto &scan_state = state.scan_state->Cast<CompressedStringScanState>();
 	auto start = segment.GetRelativeIndex(state.row_index);
 
 	auto baseptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
 	auto dict = DictionaryCompressionStorage::GetDictionary(segment, scan_state.handle);
 
-	auto header_ptr = (dictionary_compression_header_t *)baseptr;
-	auto index_buffer_offset = Load<uint32_t>((data_ptr_t)&header_ptr->index_buffer_offset);
-	auto index_buffer_ptr = (uint32_t *)(baseptr + index_buffer_offset);
+	auto header_ptr = reinterpret_cast<dictionary_compression_header_t *>(baseptr);
+	auto index_buffer_offset = Load<uint32_t>(data_ptr_cast(&header_ptr->index_buffer_offset));
+	auto index_buffer_ptr = reinterpret_cast<uint32_t *>(baseptr + index_buffer_offset);
 
-	auto base_data = (data_ptr_t)(baseptr + DICTIONARY_HEADER_SIZE);
+	auto base_data = data_ptr_cast(baseptr + DICTIONARY_HEADER_SIZE);
 	auto result_data = FlatVector::GetData<string_t>(result);
 
 	if (!ALLOW_DICT_VECTORS || scan_count != STANDARD_VECTOR_SIZE ||
@@ -502,7 +502,7 @@ void DictionaryCompressionStorage::StringScanPartial(ColumnSegment &segment, Col
 		data_ptr_t src = &base_data[((start - start_offset) * scan_state.current_width) / 8];
 		sel_t *sel_vec_ptr = scan_state.sel_vec->data();
 
-		BitpackingPrimitives::UnPackBuffer<sel_t>((data_ptr_t)sel_vec_ptr, src, decompress_count,
+		BitpackingPrimitives::UnPackBuffer<sel_t>(data_ptr_cast(sel_vec_ptr), src, decompress_count,
 		                                          scan_state.current_width);
 
 		for (idx_t i = 0; i < scan_count; i++) {
@@ -527,8 +527,8 @@ void DictionaryCompressionStorage::StringScanPartial(ColumnSegment &segment, Col
 		}
 
 		// Scanning 1024 values, emitting a dict vector
-		data_ptr_t dst = (data_ptr_t)(scan_state.sel_vec->data());
-		data_ptr_t src = (data_ptr_t)&base_data[(start * scan_state.current_width) / 8];
+		data_ptr_t dst = data_ptr_cast(scan_state.sel_vec->data());
+		data_ptr_t src = data_ptr_cast(&base_data[(start * scan_state.current_width) / 8]);
 
 		BitpackingPrimitives::UnPackBuffer<sel_t>(dst, src, scan_count, scan_state.current_width);
 
@@ -551,12 +551,12 @@ void DictionaryCompressionStorage::StringFetchRow(ColumnSegment &segment, Column
 	auto &handle = state.GetOrInsertHandle(segment);
 
 	auto baseptr = handle.Ptr() + segment.GetBlockOffset();
-	auto header_ptr = (dictionary_compression_header_t *)baseptr;
+	auto header_ptr = reinterpret_cast<dictionary_compression_header_t *>(baseptr);
 	auto dict = DictionaryCompressionStorage::GetDictionary(segment, handle);
-	auto index_buffer_offset = Load<uint32_t>((data_ptr_t)&header_ptr->index_buffer_offset);
-	auto width = (bitpacking_width_t)(Load<uint32_t>((data_ptr_t)&header_ptr->bitpacking_width));
-	auto index_buffer_ptr = (uint32_t *)(baseptr + index_buffer_offset);
-	auto base_data = (data_ptr_t)(baseptr + DICTIONARY_HEADER_SIZE);
+	auto index_buffer_offset = Load<uint32_t>(data_ptr_cast(&header_ptr->index_buffer_offset));
+	auto width = (bitpacking_width_t)Load<uint32_t>(data_ptr_cast(&header_ptr->bitpacking_width));
+	auto index_buffer_ptr = reinterpret_cast<uint32_t *>(baseptr + index_buffer_offset);
+	auto base_data = data_ptr_cast(baseptr + DICTIONARY_HEADER_SIZE);
 	auto result_data = FlatVector::GetData<string_t>(result);
 
 	// Handling non-bitpacking-group-aligned start values;
@@ -564,8 +564,8 @@ void DictionaryCompressionStorage::StringFetchRow(ColumnSegment &segment, Column
 
 	// Decompress part of selection buffer we need for this value.
 	sel_t decompression_buffer[BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE];
-	data_ptr_t src = (data_ptr_t)&base_data[((row_id - start_offset) * width) / 8];
-	BitpackingPrimitives::UnPackBuffer<sel_t>((data_ptr_t)decompression_buffer, src,
+	data_ptr_t src = data_ptr_cast(&base_data[((row_id - start_offset) * width) / 8]);
+	BitpackingPrimitives::UnPackBuffer<sel_t>(data_ptr_cast(decompression_buffer), src,
 	                                          BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE, width);
 
 	auto selection_value = decompression_buffer[start_offset];
@@ -595,18 +595,18 @@ idx_t DictionaryCompressionStorage::RequiredSpace(idx_t current_count, idx_t ind
 }
 
 StringDictionaryContainer DictionaryCompressionStorage::GetDictionary(ColumnSegment &segment, BufferHandle &handle) {
-	auto header_ptr = (dictionary_compression_header_t *)(handle.Ptr() + segment.GetBlockOffset());
+	auto header_ptr = reinterpret_cast<dictionary_compression_header_t *>(handle.Ptr() + segment.GetBlockOffset());
 	StringDictionaryContainer container;
-	container.size = Load<uint32_t>((data_ptr_t)&header_ptr->dict_size);
-	container.end = Load<uint32_t>((data_ptr_t)&header_ptr->dict_end);
+	container.size = Load<uint32_t>(data_ptr_cast(&header_ptr->dict_size));
+	container.end = Load<uint32_t>(data_ptr_cast(&header_ptr->dict_end));
 	return container;
 }
 
 void DictionaryCompressionStorage::SetDictionary(ColumnSegment &segment, BufferHandle &handle,
                                                  StringDictionaryContainer container) {
-	auto header_ptr = (dictionary_compression_header_t *)(handle.Ptr() + segment.GetBlockOffset());
-	Store<uint32_t>(container.size, (data_ptr_t)&header_ptr->dict_size);
-	Store<uint32_t>(container.end, (data_ptr_t)&header_ptr->dict_end);
+	auto header_ptr = reinterpret_cast<dictionary_compression_header_t *>(handle.Ptr() + segment.GetBlockOffset());
+	Store<uint32_t>(container.size, data_ptr_cast(&header_ptr->dict_size));
+	Store<uint32_t>(container.end, data_ptr_cast(&header_ptr->dict_end));
 }
 
 string_t DictionaryCompressionStorage::FetchStringFromDict(ColumnSegment &segment, StringDictionaryContainer dict,
@@ -621,7 +621,7 @@ string_t DictionaryCompressionStorage::FetchStringFromDict(ColumnSegment &segmen
 	auto dict_end = baseptr + dict.end;
 	auto dict_pos = dict_end - dict_offset;
 
-	auto str_ptr = (char *)(dict_pos);
+	auto str_ptr = char_ptr_cast(dict_pos);
 	return string_t(str_ptr, string_len);
 }
 

package/src/duckdb/src/storage/compression/fixed_size_uncompressed.cpp

@@ -28,14 +28,14 @@ unique_ptr<AnalyzeState> FixedSizeInitAnalyze(ColumnData &col_data, PhysicalType
 }
 
 bool FixedSizeAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = (FixedSizeAnalyzeState &)state_p;
+	auto &state = state_p.Cast<FixedSizeAnalyzeState>();
 	state.count += count;
 	return true;
 }
 
 template <class T>
 idx_t FixedSizeFinalAnalyze(AnalyzeState &state_p) {
-	auto &state = (FixedSizeAnalyzeState &)state_p;
+	auto &state = state_p.template Cast<FixedSizeAnalyzeState>();
 	return sizeof(T) * state.count;
 }
 
@@ -64,7 +64,7 @@ void UncompressedCompressState::CreateEmptySegment(idx_t row_start) {
 	auto &type = checkpointer.GetType();
 	auto compressed_segment = ColumnSegment::CreateTransientSegment(db, type, row_start);
 	if (type.InternalType() == PhysicalType::VARCHAR) {
-		auto &state = (UncompressedStringSegmentState &)*compressed_segment->GetSegmentState();
+		auto &state = compressed_segment->GetSegmentState()->Cast<UncompressedStringSegmentState>();
 		state.overflow_writer = make_uniq<WriteOverflowStringsToDisk>(checkpointer.GetColumnData().GetBlockManager());
 	}
 	current_segment = std::move(compressed_segment);
@@ -87,7 +87,7 @@ unique_ptr<CompressionState> UncompressedFunctions::InitCompression(ColumnDataCh
 }
 
 void UncompressedFunctions::Compress(CompressionState &state_p, Vector &data, idx_t count) {
-	auto &state = (UncompressedCompressState &)state_p;
+	auto &state = state_p.Cast<UncompressedCompressState>();
 	UnifiedVectorFormat vdata;
 	data.ToUnifiedFormat(count, vdata);
 
@@ -110,7 +110,7 @@ void UncompressedFunctions::Compress(CompressionState &state_p, Vector &data, id
 }
 
 void UncompressedFunctions::FinalizeCompress(CompressionState &state_p) {
-	auto &state = (UncompressedCompressState &)state_p;
+	auto &state = state_p.Cast<UncompressedCompressState>();
 	state.Finalize(state.current_segment->FinalizeAppend(state.append_state));
 }
 
@@ -134,7 +134,7 @@ unique_ptr<SegmentScanState> FixedSizeInitScan(ColumnSegment &segment) {
 template <class T>
 void FixedSizeScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
                           idx_t result_offset) {
-	auto &scan_state = (FixedSizeScanState &)*state.scan_state;
+	auto &scan_state = state.scan_state->Cast<FixedSizeScanState>();
 	auto start = segment.GetRelativeIndex(state.row_index);
 
 	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
@@ -147,7 +147,7 @@ void FixedSizeScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t
 
 template <class T>
 void FixedSizeScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	auto &scan_state = (FixedSizeScanState &)*state.scan_state;
+	auto &scan_state = state.scan_state->template Cast<FixedSizeScanState>();
 	auto start = segment.GetRelativeIndex(state.row_index);
 
 	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
@@ -185,8 +185,8 @@ struct StandardFixedSizeAppend {
 	template <class T>
 	static void Append(SegmentStatistics &stats, data_ptr_t target, idx_t target_offset, UnifiedVectorFormat &adata,
 	                   idx_t offset, idx_t count) {
-		auto sdata = (T *)adata.data;
-		auto tdata = (T *)target;
+		auto sdata = UnifiedVectorFormat::GetData<T>(adata);
+		auto tdata = reinterpret_cast<T *>(target);
 		if (!adata.validity.AllValid()) {
 			for (idx_t i = 0; i < count; i++) {
 				auto source_idx = adata.sel->get_index(offset + i);
@@ -216,8 +216,8 @@ struct ListFixedSizeAppend {
 	template <class T>
 	static void Append(SegmentStatistics &stats, data_ptr_t target, idx_t target_offset, UnifiedVectorFormat &adata,
 	                   idx_t offset, idx_t count) {
-		auto sdata = (uint64_t *)adata.data;
-		auto tdata = (uint64_t *)target;
+		auto sdata = UnifiedVectorFormat::GetData<uint64_t>(adata);
+		auto tdata = reinterpret_cast<uint64_t *>(target);
 		for (idx_t i = 0; i < count; i++) {
 			auto source_idx = adata.sel->get_index(offset + i);
 			auto target_idx = target_offset + i;