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

package/src/duckdb/src/storage/statistics/string_stats.cpp

@@ -116,7 +116,7 @@ static void ConstructValue(const_data_ptr_t data, idx_t size, data_t target[]) {
 }
 
 void StringStats::Update(BaseStatistics &stats, const string_t &value) {
-	auto data = (const_data_ptr_t)value.GetData();
+	auto data = const_data_ptr_cast(value.GetData());
 	auto size = value.GetSize();
 
 	//! we can only fit 8 bytes, so we might need to trim our string
@@ -136,12 +136,12 @@ void StringStats::Update(BaseStatistics &stats, const string_t &value) {
 		string_data.max_string_length = size;
 	}
 	if (stats.GetType().id() == LogicalTypeId::VARCHAR && !string_data.has_unicode) {
-		auto unicode = Utf8Proc::Analyze((const char *)data, size);
+		auto unicode = Utf8Proc::Analyze(const_char_ptr_cast(data), size);
 		if (unicode == UnicodeType::UNICODE) {
 			string_data.has_unicode = true;
 		} else if (unicode == UnicodeType::INVALID) {
-			throw InvalidInputException(
-			    ErrorManager::InvalidUnicodeError(string((char *)data, size), "segment statistics update"));
+			throw InvalidInputException(ErrorManager::InvalidUnicodeError(string(const_char_ptr_cast(data), size),
+			                                                              "segment statistics update"));
 		}
 	}
 }
@@ -166,7 +166,7 @@ void StringStats::Merge(BaseStatistics &stats, const BaseStatistics &other) {
 FilterPropagateResult StringStats::CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
                                                 const string &constant) {
 	auto &string_data = StringStats::GetDataUnsafe(stats);
-	auto data = (const_data_ptr_t)constant.c_str();
+	auto data = const_data_ptr_cast(constant.c_str());
 	auto size = constant.size();
 
 	idx_t value_size = size > StringStatsData::MAX_STRING_MINMAX_SIZE ? StringStatsData::MAX_STRING_MINMAX_SIZE : size;
@@ -219,10 +219,11 @@ string StringStats::ToString(const BaseStatistics &stats) {
 	auto &string_data = StringStats::GetDataUnsafe(stats);
 	idx_t min_len = GetValidMinMaxSubstring(string_data.min);
 	idx_t max_len = GetValidMinMaxSubstring(string_data.max);
-	return StringUtil::Format(
-	    "[Min: %s, Max: %s, Has Unicode: %s, Max String Length: %s]", string((const char *)string_data.min, min_len),
-	    string((const char *)string_data.max, max_len), string_data.has_unicode ? "true" : "false",
-	    string_data.has_max_string_length ? to_string(string_data.max_string_length) : "?");
+	return StringUtil::Format("[Min: %s, Max: %s, Has Unicode: %s, Max String Length: %s]",
+	                          string(const_char_ptr_cast(string_data.min), min_len),
+	                          string(const_char_ptr_cast(string_data.max), max_len),
+	                          string_data.has_unicode ? "true" : "false",
+	                          string_data.has_max_string_length ? to_string(string_data.max_string_length) : "?");
 }
 
 void StringStats::Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count) {
@@ -230,7 +231,7 @@ void StringStats::Verify(const BaseStatistics &stats, Vector &vector, const Sele
 
 	UnifiedVectorFormat vdata;
 	vector.ToUnifiedFormat(count, vdata);
-	auto data = (string_t *)vdata.data;
+	auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = sel.get_index(i);
 		auto index = vdata.sel->get_index(idx);
@@ -256,13 +257,13 @@ void StringStats::Verify(const BaseStatistics &stats, Vector &vector, const Sele
 				throw InternalException("Invalid unicode detected in vector: %s", vector.ToString(count));
 			}
 		}
-		if (StringValueComparison((const_data_ptr_t)data, MinValue<idx_t>(len, StringStatsData::MAX_STRING_MINMAX_SIZE),
-		                          string_data.min) < 0) {
+		if (StringValueComparison(const_data_ptr_cast(data),
+		                          MinValue<idx_t>(len, StringStatsData::MAX_STRING_MINMAX_SIZE), string_data.min) < 0) {
 			throw InternalException("Statistics mismatch: value is smaller than min.\nStatistics: %s\nVector: %s",
 			                        stats.ToString(), vector.ToString(count));
 		}
-		if (StringValueComparison((const_data_ptr_t)data, MinValue<idx_t>(len, StringStatsData::MAX_STRING_MINMAX_SIZE),
-		                          string_data.max) > 0) {
+		if (StringValueComparison(const_data_ptr_cast(data),
+		                          MinValue<idx_t>(len, StringStatsData::MAX_STRING_MINMAX_SIZE), string_data.max) > 0) {
 			throw InternalException("Statistics mismatch: value is bigger than max.\nStatistics: %s\nVector: %s",
 			                        stats.ToString(), vector.ToString(count));
 		}

package/src/duckdb/src/storage/table/chunk_info.cpp

@@ -241,7 +241,7 @@ void ChunkVectorInfo::Serialize(Serializer &serializer) {
 	for (idx_t i = 0; i < count; i++) {
 		deleted_tuples[sel.get_index(i)] = false;
 	}
-	serializer.WriteData((data_ptr_t)deleted_tuples, sizeof(bool) * STANDARD_VECTOR_SIZE);
+	serializer.WriteData(data_ptr_cast(deleted_tuples), sizeof(bool) * STANDARD_VECTOR_SIZE);
 }
 
 unique_ptr<ChunkInfo> ChunkVectorInfo::Deserialize(Deserializer &source) {
@@ -250,7 +250,7 @@ unique_ptr<ChunkInfo> ChunkVectorInfo::Deserialize(Deserializer &source) {
 	auto result = make_uniq<ChunkVectorInfo>(start);
 	result->any_deleted = true;
 	bool deleted_tuples[STANDARD_VECTOR_SIZE];
-	source.ReadData((data_ptr_t)deleted_tuples, sizeof(bool) * STANDARD_VECTOR_SIZE);
+	source.ReadData(data_ptr_cast(deleted_tuples), sizeof(bool) * STANDARD_VECTOR_SIZE);
 	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; i++) {
 		if (deleted_tuples[i]) {
 			result->deleted[i] = 0;

package/src/duckdb/src/storage/table/column_segment.cpp

@@ -331,7 +331,7 @@ idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const
 		// similar to the CONJUNCTION_AND, but we need to take care of the SelectionVectors (OR all of them)
 		idx_t count_total = 0;
 		SelectionVector result_sel(approved_tuple_count);
-		auto &conjunction_or = (const ConjunctionOrFilter &)filter;
+		auto &conjunction_or = filter.Cast<ConjunctionOrFilter>();
 		for (auto &child_filter : conjunction_or.child_filters) {
 			SelectionVector temp_sel;
 			temp_sel.Initialize(sel);
@@ -357,14 +357,14 @@ idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const
 		return approved_tuple_count;
 	}
 	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction_and = (const ConjunctionAndFilter &)filter;
+		auto &conjunction_and = filter.Cast<ConjunctionAndFilter>();
 		for (auto &child_filter : conjunction_and.child_filters) {
 			FilterSelection(sel, result, *child_filter, approved_tuple_count, mask);
 		}
 		return approved_tuple_count;
 	}
 	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = (const ConstantFilter &)filter;
+		auto &constant_filter = filter.Cast<ConstantFilter>();
 		// the inplace loops take the result as the last parameter
 		switch (result.GetType().InternalType()) {
 		case PhysicalType::UINT8: {

package/src/duckdb/src/storage/table/list_column_data.cpp

@@ -167,7 +167,7 @@ void ListColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vec
 	auto &list_validity = list_data.validity;
 
 	// construct the list_entry_t entries to append to the column data
-	auto input_offsets = (list_entry_t *)list_data.data;
+	auto input_offsets = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
 	auto start_offset = child_column->GetMaxEntry();
 	idx_t child_count = 0;
 
@@ -210,7 +210,7 @@ void ListColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vec
 
 	UnifiedVectorFormat vdata;
 	vdata.sel = FlatVector::IncrementalSelectionVector();
-	vdata.data = (data_ptr_t)append_offsets.get();
+	vdata.data = data_ptr_cast(append_offsets.get());
 
 	// append the list offsets
 	ColumnData::AppendData(stats, state, vdata, count);
@@ -337,7 +337,7 @@ unique_ptr<ColumnCheckpointState> ListColumnData::Checkpoint(RowGroup &row_group
 	auto base_state = ColumnData::Checkpoint(row_group, partial_block_manager, checkpoint_info);
 	auto child_state = child_column->Checkpoint(row_group, partial_block_manager, checkpoint_info);
 
-	auto &checkpoint_state = (ListColumnCheckpointState &)*base_state;
+	auto &checkpoint_state = base_state->Cast<ListColumnCheckpointState>();
 	checkpoint_state.validity_state = std::move(validity_state);
 	checkpoint_state.child_state = std::move(child_state);
 	return base_state;

package/src/duckdb/src/storage/table/row_group.cpp

@@ -502,7 +502,7 @@ void RowGroup::TemplatedScan(TransactionData transaction, CollectionScanState &s
 					if (column == COLUMN_IDENTIFIER_ROW_ID) {
 						D_ASSERT(result.data[i].GetType().InternalType() == PhysicalType::INT64);
 						result.data[i].SetVectorType(VectorType::FLAT_VECTOR);
-						auto result_data = (int64_t *)FlatVector::GetData(result.data[i]);
+						auto result_data = FlatVector::GetData<int64_t>(result.data[i]);
 						for (size_t sel_idx = 0; sel_idx < approved_tuple_count; sel_idx++) {
 							result_data[sel_idx] = this->start + current_row + sel.get_index(sel_idx);
 						}
@@ -650,7 +650,7 @@ void RowGroup::AppendVersionInfo(TransactionData transaction, idx_t count) {
 			} else {
 				D_ASSERT(version_info->info[vector_idx]->type == ChunkInfoType::VECTOR_INFO);
 				// use existing vector
-				info = (ChunkVectorInfo *)version_info->info[vector_idx].get();
+				info = &version_info->info[vector_idx]->Cast<ChunkVectorInfo>();
 			}
 			info->Append(start, end, transaction.transaction_id);
 		}
@@ -985,7 +985,7 @@ void VersionDeleteState::Delete(row_t row_id) {
 			info.version_info->info[vector_idx] =
 			    make_uniq<ChunkVectorInfo>(info.start + vector_idx * STANDARD_VECTOR_SIZE);
 		} else if (info.version_info->info[vector_idx]->type == ChunkInfoType::CONSTANT_INFO) {
-			auto &constant = (ChunkConstantInfo &)*info.version_info->info[vector_idx];
+			auto &constant = info.version_info->info[vector_idx]->Cast<ChunkConstantInfo>();
 			// info exists but it's a constant info: convert to a vector info
 			auto new_info = make_uniq<ChunkVectorInfo>(info.start + vector_idx * STANDARD_VECTOR_SIZE);
 			new_info->insert_id = constant.insert_id.load();
@@ -995,7 +995,7 @@ void VersionDeleteState::Delete(row_t row_id) {
 			info.version_info->info[vector_idx] = std::move(new_info);
 		}
 		D_ASSERT(info.version_info->info[vector_idx]->type == ChunkInfoType::VECTOR_INFO);
-		current_info = (ChunkVectorInfo *)info.version_info->info[vector_idx].get();
+		current_info = &info.version_info->info[vector_idx]->Cast<ChunkVectorInfo>();
 		current_chunk = vector_idx;
 		chunk_row = vector_idx * STANDARD_VECTOR_SIZE;
 	}

package/src/duckdb/src/storage/table/standard_column_data.cpp

@@ -189,7 +189,7 @@ unique_ptr<ColumnCheckpointState> StandardColumnData::Checkpoint(RowGroup &row_g
                                                                  ColumnCheckpointInfo &checkpoint_info) {
 	auto validity_state = validity.Checkpoint(row_group, partial_block_manager, checkpoint_info);
 	auto base_state = ColumnData::Checkpoint(row_group, partial_block_manager, checkpoint_info);
-	auto &checkpoint_state = (StandardColumnCheckpointState &)*base_state;
+	auto &checkpoint_state = base_state->Cast<StandardColumnCheckpointState>();
 	checkpoint_state.validity_state = std::move(validity_state);
 	return base_state;
 }

package/src/duckdb/src/storage/table/update_segment.cpp

@@ -48,9 +48,9 @@ Value UpdateInfo::GetValue(idx_t index) {
 
 	switch (type.id()) {
 	case LogicalTypeId::VALIDITY:
-		return Value::BOOLEAN(((bool *)tuple_data)[index]);
+		return Value::BOOLEAN(reinterpret_cast<bool *>(tuple_data)[index]);
 	case LogicalTypeId::INTEGER:
-		return Value::INTEGER(((int32_t *)tuple_data)[index]);
+		return Value::INTEGER(reinterpret_cast<int32_t *>(tuple_data)[index]);
 	default:
 		throw NotImplementedException("Unimplemented type for UpdateInfo::GetValue");
 	}
@@ -85,7 +85,7 @@ void UpdateInfo::Verify() {
 // Update Fetch
 //===--------------------------------------------------------------------===//
 static void MergeValidityInfo(UpdateInfo *current, ValidityMask &result_mask) {
-	auto info_data = (bool *)current->tuple_data;
+	auto info_data = reinterpret_cast<bool *>(current->tuple_data);
 	for (idx_t i = 0; i < current->N; i++) {
 		result_mask.Set(current->tuples[i], info_data[i]);
 	}
@@ -100,7 +100,7 @@ static void UpdateMergeValidity(transaction_t start_time, transaction_t transact
 
 template <class T>
 static void MergeUpdateInfo(UpdateInfo *current, T *result_data) {
-	auto info_data = (T *)current->tuple_data;
+	auto info_data = reinterpret_cast<T *>(current->tuple_data);
 	if (current->N == STANDARD_VECTOR_SIZE) {
 		// special case: update touches ALL tuples of this vector
 		// in this case we can just memcpy the data
@@ -241,7 +241,7 @@ void UpdateSegment::FetchCommitted(idx_t vector_index, Vector &result) {
 //===--------------------------------------------------------------------===//
 static void MergeUpdateInfoRangeValidity(UpdateInfo *current, idx_t start, idx_t end, idx_t result_offset,
                                          ValidityMask &result_mask) {
-	auto info_data = (bool *)current->tuple_data;
+	auto info_data = reinterpret_cast<bool *>(current->tuple_data);
 	for (idx_t i = 0; i < current->N; i++) {
 		auto tuple_idx = current->tuples[i];
 		if (tuple_idx < start) {
@@ -261,7 +261,7 @@ static void FetchCommittedRangeValidity(UpdateInfo *info, idx_t start, idx_t end
 
 template <class T>
 static void MergeUpdateInfoRange(UpdateInfo *current, idx_t start, idx_t end, idx_t result_offset, T *result_data) {
-	auto info_data = (T *)current->tuple_data;
+	auto info_data = reinterpret_cast<T *>(current->tuple_data);
 	for (idx_t i = 0; i < current->N; i++) {
 		auto tuple_idx = current->tuples[i];
 		if (tuple_idx < start) {
@@ -352,7 +352,7 @@ static void FetchRowValidity(transaction_t start_time, transaction_t transaction
                              Vector &result, idx_t result_idx) {
 	auto &result_mask = FlatVector::Validity(result);
 	UpdateInfo::UpdatesForTransaction(info, start_time, transaction_id, [&](UpdateInfo *current) {
-		auto info_data = (bool *)current->tuple_data;
+		auto info_data = reinterpret_cast<bool *>(current->tuple_data);
 		// FIXME: we could do a binary search in here
 		for (idx_t i = 0; i < current->N; i++) {
 			if (current->tuples[i] == row_idx) {
@@ -576,7 +576,7 @@ void UpdateSegment::InitializeUpdateInfo(UpdateInfo &info, row_t *ids, const Sel
 static void InitializeUpdateValidity(UpdateInfo *base_info, Vector &base_data, UpdateInfo *update_info, Vector &update,
                                      const SelectionVector &sel) {
 	auto &update_mask = FlatVector::Validity(update);
-	auto tuple_data = (bool *)update_info->tuple_data;
+	auto tuple_data = reinterpret_cast<bool *>(update_info->tuple_data);
 
 	if (!update_mask.AllValid()) {
 		for (idx_t i = 0; i < update_info->N; i++) {
@@ -590,7 +590,7 @@ static void InitializeUpdateValidity(UpdateInfo *base_info, Vector &base_data, U
 	}
 
 	auto &base_mask = FlatVector::Validity(base_data);
-	auto base_tuple_data = (bool *)base_info->tuple_data;
+	auto base_tuple_data = reinterpret_cast<bool *>(base_info->tuple_data);
 	if (!base_mask.AllValid()) {
 		for (idx_t i = 0; i < base_info->N; i++) {
 			base_tuple_data[i] = base_mask.RowIsValidUnsafe(base_info->tuples[i]);
@@ -1045,10 +1045,10 @@ static idx_t SortSelectionVector(SelectionVector &sel, idx_t count, row_t *ids)
 UpdateInfo *CreateEmptyUpdateInfo(TransactionData transaction, idx_t type_size, idx_t count,
                                   unsafe_unique_array<char> &data) {
 	data = make_unsafe_uniq_array<char>(sizeof(UpdateInfo) + (sizeof(sel_t) + type_size) * STANDARD_VECTOR_SIZE);
-	auto update_info = (UpdateInfo *)data.get();
+	auto update_info = reinterpret_cast<UpdateInfo *>(data.get());
 	update_info->max = STANDARD_VECTOR_SIZE;
-	update_info->tuples = (sel_t *)(((data_ptr_t)update_info) + sizeof(UpdateInfo));
-	update_info->tuple_data = ((data_ptr_t)update_info) + sizeof(UpdateInfo) + sizeof(sel_t) * update_info->max;
+	update_info->tuples = reinterpret_cast<sel_t *>((data_ptr_cast(update_info)) + sizeof(UpdateInfo));
+	update_info->tuple_data = (data_ptr_cast(update_info)) + sizeof(UpdateInfo) + sizeof(sel_t) * update_info->max;
 	update_info->version_number = transaction.transaction_id;
 	return update_info;
 }

package/src/duckdb/src/storage/wal_replay.cpp

@@ -486,7 +486,7 @@ void ReplayState::ReplayDelete() {
 
 	D_ASSERT(chunk.ColumnCount() == 1 && chunk.data[0].GetType() == LogicalType::ROW_TYPE);
 	row_t row_ids[1];
-	Vector row_identifiers(LogicalType::ROW_TYPE, (data_ptr_t)row_ids);
+	Vector row_identifiers(LogicalType::ROW_TYPE, data_ptr_cast(row_ids));
 
 	auto source_ids = FlatVector::GetData<row_t>(chunk.data[0]);
 	// delete the tuples from the current table

package/src/duckdb/src/transaction/cleanup_state.cpp

@@ -28,12 +28,12 @@ void CleanupState::CleanupEntry(UndoFlags type, data_ptr_t data) {
 		break;
 	}
 	case UndoFlags::DELETE_TUPLE: {
-		auto info = (DeleteInfo *)data;
+		auto info = reinterpret_cast<DeleteInfo *>(data);
 		CleanupDelete(*info);
 		break;
 	}
 	case UndoFlags::UPDATE_TUPLE: {
-		auto info = (UpdateInfo *)data;
+		auto info = reinterpret_cast<UpdateInfo *>(data);
 		CleanupUpdate(*info);
 		break;
 	}
@@ -80,7 +80,7 @@ void CleanupState::Flush() {
 	}
 
 	// set up the row identifiers vector
-	Vector row_identifiers(LogicalType::ROW_TYPE, (data_ptr_t)row_numbers);
+	Vector row_identifiers(LogicalType::ROW_TYPE, data_ptr_cast(row_numbers));
 
 	// delete the tuples from all the indexes
 	try {

package/src/duckdb/src/transaction/commit_state.cpp

@@ -45,7 +45,7 @@ void CommitState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) {
 			D_ASSERT(table_entry.IsDuckTable());
 			// ALTER TABLE statement, read the extra data after the entry
 			auto extra_data_size = Load<idx_t>(dataptr);
-			auto extra_data = (data_ptr_t)(dataptr + sizeof(idx_t));
+			auto extra_data = data_ptr_cast(dataptr + sizeof(idx_t));
 
 			BufferedDeserializer source(extra_data, extra_data_size);
 			string column_name = source.Read<string>();
@@ -72,7 +72,7 @@ void CommitState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) {
 		if (entry.type == CatalogType::VIEW_ENTRY) {
 			// ALTER TABLE statement, read the extra data after the entry
 			auto extra_data_size = Load<idx_t>(dataptr);
-			auto extra_data = (data_ptr_t)(dataptr + sizeof(idx_t));
+			auto extra_data = data_ptr_cast(dataptr + sizeof(idx_t));
 			// deserialize it
 			BufferedDeserializer source(extra_data, extra_data_size);
 			string column_name = source.Read<string>();
@@ -247,7 +247,7 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 	}
 	case UndoFlags::INSERT_TUPLE: {
 		// append:
-		auto info = (AppendInfo *)data;
+		auto info = reinterpret_cast<AppendInfo *>(data);
 		if (HAS_LOG && !info->table->info->IsTemporary()) {
 			info->table->WriteToLog(*log, info->start_row, info->count);
 		}
@@ -257,7 +257,7 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 	}
 	case UndoFlags::DELETE_TUPLE: {
 		// deletion:
-		auto info = (DeleteInfo *)data;
+		auto info = reinterpret_cast<DeleteInfo *>(data);
 		if (HAS_LOG && !info->table->info->IsTemporary()) {
 			WriteDelete(*info);
 		}
@@ -267,7 +267,7 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 	}
 	case UndoFlags::UPDATE_TUPLE: {
 		// update:
-		auto info = (UpdateInfo *)data;
+		auto info = reinterpret_cast<UpdateInfo *>(data);
 		if (HAS_LOG && !info->segment->column_data.GetTableInfo().IsTemporary()) {
 			WriteUpdate(*info);
 		}
@@ -293,14 +293,14 @@ void CommitState::RevertCommit(UndoFlags type, data_ptr_t data) {
 		break;
 	}
 	case UndoFlags::INSERT_TUPLE: {
-		auto info = (AppendInfo *)data;
+		auto info = reinterpret_cast<AppendInfo *>(data);
 		// revert this append
 		info->table->RevertAppend(info->start_row, info->count);
 		break;
 	}
 	case UndoFlags::DELETE_TUPLE: {
 		// deletion:
-		auto info = (DeleteInfo *)data;
+		auto info = reinterpret_cast<DeleteInfo *>(data);
 		info->table->info->cardinality += info->count;
 		// revert the commit by writing the (uncommitted) transaction_id back into the version info
 		info->vinfo->CommitDelete(transaction_id, info->rows, info->count);
@@ -308,7 +308,7 @@ void CommitState::RevertCommit(UndoFlags type, data_ptr_t data) {
 	}
 	case UndoFlags::UPDATE_TUPLE: {
 		// update:
-		auto info = (UpdateInfo *)data;
+		auto info = reinterpret_cast<UpdateInfo *>(data);
 		info->version_number = transaction_id;
 		break;
 	}

package/src/duckdb/src/transaction/duck_transaction.cpp

@@ -44,7 +44,7 @@ DuckTransaction &DuckTransaction::Get(ClientContext &context, Catalog &catalog)
 	if (!transaction.IsDuckTransaction()) {
 		throw InternalException("DuckTransaction::Get called on non-DuckDB transaction");
 	}
-	return (DuckTransaction &)transaction;
+	return transaction.Cast<DuckTransaction>();
 }
 
 LocalStorage &DuckTransaction::GetLocalStorage() {
@@ -71,8 +71,8 @@ void DuckTransaction::PushCatalogEntry(CatalogEntry &entry, data_ptr_t extra_dat
 }
 
 void DuckTransaction::PushDelete(DataTable &table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row) {
-	auto delete_info =
-	    (DeleteInfo *)undo_buffer.CreateEntry(UndoFlags::DELETE_TUPLE, sizeof(DeleteInfo) + sizeof(row_t) * count);
+	auto delete_info = reinterpret_cast<DeleteInfo *>(
+	    undo_buffer.CreateEntry(UndoFlags::DELETE_TUPLE, sizeof(DeleteInfo) + sizeof(row_t) * count));
 	delete_info->vinfo = vinfo;
 	delete_info->table = &table;
 	delete_info->count = count;
@@ -81,18 +81,20 @@ void DuckTransaction::PushDelete(DataTable &table, ChunkVectorInfo *vinfo, row_t
 }
 
 void DuckTransaction::PushAppend(DataTable &table, idx_t start_row, idx_t row_count) {
-	auto append_info = (AppendInfo *)undo_buffer.CreateEntry(UndoFlags::INSERT_TUPLE, sizeof(AppendInfo));
+	auto append_info =
+	    reinterpret_cast<AppendInfo *>(undo_buffer.CreateEntry(UndoFlags::INSERT_TUPLE, sizeof(AppendInfo)));
 	append_info->table = &table;
 	append_info->start_row = start_row;
 	append_info->count = row_count;
 }
 
 UpdateInfo *DuckTransaction::CreateUpdateInfo(idx_t type_size, idx_t entries) {
-	auto update_info = (UpdateInfo *)undo_buffer.CreateEntry(
+	data_ptr_t base_info = undo_buffer.CreateEntry(
 	    UndoFlags::UPDATE_TUPLE, sizeof(UpdateInfo) + (sizeof(sel_t) + type_size) * STANDARD_VECTOR_SIZE);
+	auto update_info = reinterpret_cast<UpdateInfo *>(base_info);
 	update_info->max = STANDARD_VECTOR_SIZE;
-	update_info->tuples = (sel_t *)(((data_ptr_t)update_info) + sizeof(UpdateInfo));
-	update_info->tuple_data = ((data_ptr_t)update_info) + sizeof(UpdateInfo) + sizeof(sel_t) * update_info->max;
+	update_info->tuples = reinterpret_cast<sel_t *>(base_info + sizeof(UpdateInfo));
+	update_info->tuple_data = base_info + sizeof(UpdateInfo) + sizeof(sel_t) * update_info->max;
 	update_info->version_number = transaction_id;
 	return update_info;
 }

package/src/duckdb/src/transaction/duck_transaction_manager.cpp

@@ -61,7 +61,7 @@ DuckTransactionManager &DuckTransactionManager::Get(AttachedDatabase &db) {
 	if (!transaction_manager.IsDuckTransactionManager()) {
 		throw InternalException("Calling DuckTransactionManager::Get on non-DuckDB transaction manager");
 	}
-	return (DuckTransactionManager &)transaction_manager;
+	return reinterpret_cast<DuckTransactionManager &>(transaction_manager);
 }
 
 Transaction *DuckTransactionManager::StartTransaction(ClientContext &context) {
@@ -152,7 +152,7 @@ void DuckTransactionManager::Checkpoint(ClientContext &context, bool force) {
 
 				// remove the transaction id from the list of active transactions
 				// potentially resulting in garbage collection
-				RemoveTransaction(transaction.get());
+				RemoveTransaction(*transaction);
 				if (transaction_context) {
 					transaction_context->transaction.ClearTransaction();
 				}
@@ -164,7 +164,7 @@ void DuckTransactionManager::Checkpoint(ClientContext &context, bool force) {
 	storage_manager.CreateCheckpoint();
 }
 
-bool DuckTransactionManager::CanCheckpoint(DuckTransaction *current) {
+bool DuckTransactionManager::CanCheckpoint(optional_ptr<DuckTransaction> current) {
 	if (db.IsSystem()) {
 		return false;
 	}
@@ -176,7 +176,7 @@ bool DuckTransactionManager::CanCheckpoint(DuckTransaction *current) {
 		return false;
 	}
 	for (auto &transaction : active_transactions) {
-		if (transaction.get() != current) {
+		if (transaction.get() != current.get()) {
 			return false;
 		}
 	}
@@ -184,14 +184,14 @@ bool DuckTransactionManager::CanCheckpoint(DuckTransaction *current) {
 }
 
 string DuckTransactionManager::CommitTransaction(ClientContext &context, Transaction *transaction_p) {
-	auto transaction = (DuckTransaction *)transaction_p;
+	auto &transaction = transaction_p->Cast<DuckTransaction>();
 	vector<ClientLockWrapper> client_locks;
 	auto lock = make_uniq<lock_guard<mutex>>(transaction_lock);
 	CheckpointLock checkpoint_lock(*this);
 	// check if we can checkpoint
-	bool checkpoint = thread_is_checkpointing ? false : CanCheckpoint(transaction);
+	bool checkpoint = thread_is_checkpointing ? false : CanCheckpoint(&transaction);
 	if (checkpoint) {
-		if (transaction->AutomaticCheckpoint(db)) {
+		if (transaction.AutomaticCheckpoint(db)) {
 			checkpoint_lock.Lock();
 			// we might be able to checkpoint: lock all clients
 			// to avoid deadlock we release the transaction lock while locking the clients
@@ -200,7 +200,7 @@ string DuckTransactionManager::CommitTransaction(ClientContext &context, Transac
 			LockClients(client_locks, context);
 
 			lock = make_uniq<lock_guard<mutex>>(transaction_lock);
-			checkpoint = CanCheckpoint(transaction);
+			checkpoint = CanCheckpoint(&transaction);
 			if (!checkpoint) {
 				checkpoint_lock.Unlock();
 				client_locks.clear();
@@ -212,12 +212,12 @@ string DuckTransactionManager::CommitTransaction(ClientContext &context, Transac
 	// obtain a commit id for the transaction
 	transaction_t commit_id = current_start_timestamp++;
 	// commit the UndoBuffer of the transaction
-	string error = transaction->Commit(db, commit_id, checkpoint);
+	string error = transaction.Commit(db, commit_id, checkpoint);
 	if (!error.empty()) {
 		// commit unsuccessful: rollback the transaction instead
 		checkpoint = false;
-		transaction->commit_id = 0;
-		transaction->Rollback();
+		transaction.commit_id = 0;
+		transaction.Rollback();
 	}
 	if (!checkpoint) {
 		// we won't checkpoint after all: unlock the clients again
@@ -239,19 +239,19 @@ string DuckTransactionManager::CommitTransaction(ClientContext &context, Transac
 }
 
 void DuckTransactionManager::RollbackTransaction(Transaction *transaction_p) {
-	auto transaction = (DuckTransaction *)transaction_p;
+	auto &transaction = transaction_p->Cast<DuckTransaction>();
 	// obtain the transaction lock during this function
 	lock_guard<mutex> lock(transaction_lock);
 
 	// rollback the transaction
-	transaction->Rollback();
+	transaction.Rollback();
 
 	// remove the transaction id from the list of active transactions
 	// potentially resulting in garbage collection
 	RemoveTransaction(transaction);
 }
 
-void DuckTransactionManager::RemoveTransaction(DuckTransaction *transaction) noexcept {
+void DuckTransactionManager::RemoveTransaction(DuckTransaction &transaction) noexcept {
 	// remove the transaction from the list of active transactions
 	idx_t t_index = active_transactions.size();
 	// check for the lowest and highest start time in the list of transactions
@@ -259,7 +259,7 @@ void DuckTransactionManager::RemoveTransaction(DuckTransaction *transaction) noe
 	transaction_t lowest_transaction_id = MAX_TRANSACTION_ID;
 	transaction_t lowest_active_query = MAXIMUM_QUERY_ID;
 	for (idx_t i = 0; i < active_transactions.size(); i++) {
-		if (active_transactions[i].get() == transaction) {
+		if (active_transactions[i].get() == &transaction) {
 			t_index = i;
 		} else {
 			transaction_t active_query = active_transactions[i]->active_query;
@@ -275,7 +275,7 @@ void DuckTransactionManager::RemoveTransaction(DuckTransaction *transaction) noe
 	D_ASSERT(t_index != active_transactions.size());
 	auto current_transaction = std::move(active_transactions[t_index]);
 	auto current_query = DatabaseManager::Get(db).ActiveQueryNumber();
-	if (transaction->commit_id != 0) {
+	if (transaction.commit_id != 0) {
 		// the transaction was committed, add it to the list of recently
 		// committed transactions
 		recently_committed_transactions.push_back(std::move(current_transaction));

package/src/duckdb/src/transaction/rollback_state.cpp

@@ -22,19 +22,19 @@ void RollbackState::RollbackEntry(UndoFlags type, data_ptr_t data) {
 		break;
 	}
 	case UndoFlags::INSERT_TUPLE: {
-		auto info = (AppendInfo *)data;
+		auto info = reinterpret_cast<AppendInfo *>(data);
 		// revert the append in the base table
 		info->table->RevertAppend(info->start_row, info->count);
 		break;
 	}
 	case UndoFlags::DELETE_TUPLE: {
-		auto info = (DeleteInfo *)data;
+		auto info = reinterpret_cast<DeleteInfo *>(data);
 		// reset the deleted flag on rollback
 		info->vinfo->CommitDelete(NOT_DELETED_ID, info->rows, info->count);
 		break;
 	}
 	case UndoFlags::UPDATE_TUPLE: {
-		auto info = (UpdateInfo *)data;
+		auto info = reinterpret_cast<UpdateInfo *>(data);
 		info->segment->RollbackUpdate(*info);
 		break;
 	}

package/src/duckdb/src/verification/prepared_statement_verifier.cpp

@@ -50,7 +50,7 @@ void PreparedStatementVerifier::ConvertConstants(unique_ptr<ParsedExpression> &c
 		// check if the value already exists
 		idx_t index = values.size();
 		for (idx_t v_idx = 0; v_idx < values.size(); v_idx++) {
-			if (values[v_idx]->Equals(child.get())) {
+			if (values[v_idx]->Equals(*child)) {
 				// duplicate value! refer to the original value
 				index = v_idx;
 				break;

package/src/duckdb/src/verification/statement_verifier.cpp

@@ -57,7 +57,7 @@ void StatementVerifier::CheckExpressions(const StatementVerifier &other) const {
 
 	// Check equality
 	if (other.RequireEquality()) {
-		D_ASSERT(statement->Equals(other.statement.get()));
+		D_ASSERT(statement->Equals(*other.statement));
 	}
 
 #ifdef DEBUG
@@ -66,7 +66,6 @@ void StatementVerifier::CheckExpressions(const StatementVerifier &other) const {
 	const auto expr_count = select_list.size();
 	if (other.RequireEquality()) {
 		for (idx_t i = 0; i < expr_count; i++) {
-			D_ASSERT(!select_list[i]->Equals(nullptr));
 			// Run the ToString, to verify that it doesn't crash
 			select_list[i]->ToString();
 
@@ -75,7 +74,7 @@ void StatementVerifier::CheckExpressions(const StatementVerifier &other) const {
 			}
 
 			// Check that the expressions are equivalent
-			D_ASSERT(select_list[i]->Equals(other.select_list[i].get()));
+			D_ASSERT(select_list[i]->Equals(*other.select_list[i]));
 			// Check that the hashes are equivalent too
 			D_ASSERT(select_list[i]->Hash() == other.select_list[i]->Hash());
 
@@ -96,7 +95,7 @@ void StatementVerifier::CheckExpressions() const {
 			auto hash2 = select_list[inner_idx]->Hash();
 			if (hash != hash2) {
 				// if the hashes are not equivalent, the expressions should not be equivalent
-				D_ASSERT(!select_list[outer_idx]->Equals(select_list[inner_idx].get()));
+				D_ASSERT(!select_list[outer_idx]->Equals(*select_list[inner_idx]));
 			}
 		}
 	}

package/src/duckdb/third_party/hyperloglog/hyperloglog.hpp

@@ -17,9 +17,9 @@ namespace duckdb_hll {
 #define HLL_C_OK  0
 #define HLL_C_ERR -1
 
-typedef struct {
+struct robj {
 	void *ptr;
-} robj;
+};
 
 //! Create a new empty HyperLogLog object
 robj *hll_create(void);

package/src/duckdb/third_party/pcg/pcg_extras.hpp

@@ -46,7 +46,7 @@
 #include <iterator>
 
 #ifdef __GNUC__
-    #include <cxxabi.h>
+#include <cxxabi.h>
 #endif
 
 /*