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

package/src/duckdb/src/execution/expression_executor/execute_case.cpp

@@ -27,20 +27,20 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundCaseE
 
 void ExpressionExecutor::Execute(const BoundCaseExpression &expr, ExpressionState *state_p, const SelectionVector *sel,
                                  idx_t count, Vector &result) {
-	auto state = (CaseExpressionState *)state_p;
+	auto &state = state_p->Cast<CaseExpressionState>();
 
-	state->intermediate_chunk.Reset();
+	state.intermediate_chunk.Reset();
 
 	// first execute the check expression
-	auto current_true_sel = &state->true_sel;
-	auto current_false_sel = &state->false_sel;
+	auto current_true_sel = &state.true_sel;
+	auto current_false_sel = &state.false_sel;
 	auto current_sel = sel;
 	idx_t current_count = count;
 	for (idx_t i = 0; i < expr.case_checks.size(); i++) {
 		auto &case_check = expr.case_checks[i];
-		auto &intermediate_result = state->intermediate_chunk.data[i * 2 + 1];
-		auto check_state = state->child_states[i * 2].get();
-		auto then_state = state->child_states[i * 2 + 1].get();
+		auto &intermediate_result = state.intermediate_chunk.data[i * 2 + 1];
+		auto check_state = state.child_states[i * 2].get();
+		auto then_state = state.child_states[i * 2 + 1].get();
 
 		idx_t tcount =
 		    Select(*case_check.when_expr, check_state, current_sel, current_count, current_true_sel, current_false_sel);
@@ -68,13 +68,13 @@ void ExpressionExecutor::Execute(const BoundCaseExpression &expr, ExpressionStat
 		}
 	}
 	if (current_count > 0) {
-		auto else_state = state->child_states.back().get();
+		auto else_state = state.child_states.back().get();
 		if (current_count == count) {
 			// everything was false, we can just evaluate the else expression directly
 			Execute(*expr.else_expr, else_state, sel, count, result);
 			return;
 		} else {
-			auto &intermediate_result = state->intermediate_chunk.data[expr.case_checks.size() * 2];
+			auto &intermediate_result = state.intermediate_chunk.data[expr.case_checks.size() * 2];
 
 			D_ASSERT(current_sel);
 			Execute(*expr.else_expr, else_state, current_sel, current_count, intermediate_result);
@@ -105,7 +105,7 @@ void TemplatedFillLoop(Vector &vector, Vector &result, const SelectionVector &se
 	} else {
 		UnifiedVectorFormat vdata;
 		vector.ToUnifiedFormat(count, vdata);
-		auto data = (T *)vdata.data;
+		auto data = UnifiedVectorFormat::GetData<T>(vdata);
 		for (idx_t i = 0; i < count; i++) {
 			auto source_idx = vdata.sel->get_index(i);
 			auto res_idx = sel.get_index(i);

package/src/duckdb/src/execution/expression_executor/execute_conjunction.cpp

@@ -56,7 +56,7 @@ void ExpressionExecutor::Execute(const BoundConjunctionExpression &expr, Express
 idx_t ExpressionExecutor::Select(const BoundConjunctionExpression &expr, ExpressionState *state_p,
                                  const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
                                  SelectionVector *false_sel) {
-	auto state = (ConjunctionState *)state_p;
+	auto &state = state_p->Cast<ConjunctionState>();
 
 	if (expr.type == ExpressionType::CONJUNCTION_AND) {
 		// get runtime statistics
@@ -75,8 +75,8 @@ idx_t ExpressionExecutor::Select(const BoundConjunctionExpression &expr, Express
 			true_sel = temp_true.get();
 		}
 		for (idx_t i = 0; i < expr.children.size(); i++) {
-			idx_t tcount = Select(*expr.children[state->adaptive_filter->permutation[i]],
-			                      state->child_states[state->adaptive_filter->permutation[i]].get(), current_sel,
+			idx_t tcount = Select(*expr.children[state.adaptive_filter->permutation[i]],
+			                      state.child_states[state.adaptive_filter->permutation[i]].get(), current_sel,
 			                      current_count, true_sel, temp_false.get());
 			idx_t fcount = current_count - tcount;
 			if (fcount > 0 && false_sel) {
@@ -99,7 +99,7 @@ idx_t ExpressionExecutor::Select(const BoundConjunctionExpression &expr, Express
 
 		// adapt runtime statistics
 		auto end_time = high_resolution_clock::now();
-		state->adaptive_filter->AdaptRuntimeStatistics(duration_cast<duration<double>>(end_time - start_time).count());
+		state.adaptive_filter->AdaptRuntimeStatistics(duration_cast<duration<double>>(end_time - start_time).count());
 		return current_count;
 	} else {
 		// get runtime statistics
@@ -118,8 +118,8 @@ idx_t ExpressionExecutor::Select(const BoundConjunctionExpression &expr, Express
 			false_sel = temp_false.get();
 		}
 		for (idx_t i = 0; i < expr.children.size(); i++) {
-			idx_t tcount = Select(*expr.children[state->adaptive_filter->permutation[i]],
-			                      state->child_states[state->adaptive_filter->permutation[i]].get(), current_sel,
+			idx_t tcount = Select(*expr.children[state.adaptive_filter->permutation[i]],
+			                      state.child_states[state.adaptive_filter->permutation[i]].get(), current_sel,
 			                      current_count, temp_true.get(), false_sel);
 			if (tcount > 0) {
 				if (true_sel) {
@@ -136,7 +136,7 @@ idx_t ExpressionExecutor::Select(const BoundConjunctionExpression &expr, Express
 
 		// adapt runtime statistics
 		auto end_time = high_resolution_clock::now();
-		state->adaptive_filter->AdaptRuntimeStatistics(duration_cast<duration<double>>(end_time - start_time).count());
+		state.adaptive_filter->AdaptRuntimeStatistics(duration_cast<duration<double>>(end_time - start_time).count());
 		return result_count;
 	}
 }

package/src/duckdb/src/execution/expression_executor.cpp

@@ -144,25 +144,25 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const Expression
                                                                 ExpressionExecutorState &state) {
 	switch (expr.expression_class) {
 	case ExpressionClass::BOUND_REF:
-		return InitializeState((const BoundReferenceExpression &)expr, state);
+		return InitializeState(expr.Cast<BoundReferenceExpression>(), state);
 	case ExpressionClass::BOUND_BETWEEN:
-		return InitializeState((const BoundBetweenExpression &)expr, state);
+		return InitializeState(expr.Cast<BoundBetweenExpression>(), state);
 	case ExpressionClass::BOUND_CASE:
-		return InitializeState((const BoundCaseExpression &)expr, state);
+		return InitializeState(expr.Cast<BoundCaseExpression>(), state);
 	case ExpressionClass::BOUND_CAST:
-		return InitializeState((const BoundCastExpression &)expr, state);
+		return InitializeState(expr.Cast<BoundCastExpression>(), state);
 	case ExpressionClass::BOUND_COMPARISON:
-		return InitializeState((const BoundComparisonExpression &)expr, state);
+		return InitializeState(expr.Cast<BoundComparisonExpression>(), state);
 	case ExpressionClass::BOUND_CONJUNCTION:
-		return InitializeState((const BoundConjunctionExpression &)expr, state);
+		return InitializeState(expr.Cast<BoundConjunctionExpression>(), state);
 	case ExpressionClass::BOUND_CONSTANT:
-		return InitializeState((const BoundConstantExpression &)expr, state);
+		return InitializeState(expr.Cast<BoundConstantExpression>(), state);
 	case ExpressionClass::BOUND_FUNCTION:
-		return InitializeState((const BoundFunctionExpression &)expr, state);
+		return InitializeState(expr.Cast<BoundFunctionExpression>(), state);
 	case ExpressionClass::BOUND_OPERATOR:
-		return InitializeState((const BoundOperatorExpression &)expr, state);
+		return InitializeState(expr.Cast<BoundOperatorExpression>(), state);
 	case ExpressionClass::BOUND_PARAMETER:
-		return InitializeState((const BoundParameterExpression &)expr, state);
+		return InitializeState(expr.Cast<BoundParameterExpression>(), state);
 	default:
 		throw InternalException("Attempting to initialize state of expression of unknown type!");
 	}
@@ -187,34 +187,34 @@ void ExpressionExecutor::Execute(const Expression &expr, ExpressionState *state,
 	}
 	switch (expr.expression_class) {
 	case ExpressionClass::BOUND_BETWEEN:
-		Execute((const BoundBetweenExpression &)expr, state, sel, count, result);
+		Execute(expr.Cast<BoundBetweenExpression>(), state, sel, count, result);
 		break;
 	case ExpressionClass::BOUND_REF:
-		Execute((const BoundReferenceExpression &)expr, state, sel, count, result);
+		Execute(expr.Cast<BoundReferenceExpression>(), state, sel, count, result);
 		break;
 	case ExpressionClass::BOUND_CASE:
-		Execute((const BoundCaseExpression &)expr, state, sel, count, result);
+		Execute(expr.Cast<BoundCaseExpression>(), state, sel, count, result);
 		break;
 	case ExpressionClass::BOUND_CAST:
-		Execute((const BoundCastExpression &)expr, state, sel, count, result);
+		Execute(expr.Cast<BoundCastExpression>(), state, sel, count, result);
 		break;
 	case ExpressionClass::BOUND_COMPARISON:
-		Execute((const BoundComparisonExpression &)expr, state, sel, count, result);
+		Execute(expr.Cast<BoundComparisonExpression>(), state, sel, count, result);
 		break;
 	case ExpressionClass::BOUND_CONJUNCTION:
-		Execute((const BoundConjunctionExpression &)expr, state, sel, count, result);
+		Execute(expr.Cast<BoundConjunctionExpression>(), state, sel, count, result);
 		break;
 	case ExpressionClass::BOUND_CONSTANT:
-		Execute((const BoundConstantExpression &)expr, state, sel, count, result);
+		Execute(expr.Cast<BoundConstantExpression>(), state, sel, count, result);
 		break;
 	case ExpressionClass::BOUND_FUNCTION:
-		Execute((const BoundFunctionExpression &)expr, state, sel, count, result);
+		Execute(expr.Cast<BoundFunctionExpression>(), state, sel, count, result);
 		break;
 	case ExpressionClass::BOUND_OPERATOR:
-		Execute((const BoundOperatorExpression &)expr, state, sel, count, result);
+		Execute(expr.Cast<BoundOperatorExpression>(), state, sel, count, result);
 		break;
 	case ExpressionClass::BOUND_PARAMETER:
-		Execute((const BoundParameterExpression &)expr, state, sel, count, result);
+		Execute(expr.Cast<BoundParameterExpression>(), state, sel, count, result);
 		break;
 	default:
 		throw InternalException("Attempting to execute expression of unknown type!");
@@ -242,7 +242,7 @@ idx_t ExpressionExecutor::Select(const Expression &expr, ExpressionState *state,
 }
 
 template <bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
-static inline idx_t DefaultSelectLoop(const SelectionVector *bsel, uint8_t *__restrict bdata, ValidityMask &mask,
+static inline idx_t DefaultSelectLoop(const SelectionVector *bsel, const uint8_t *__restrict bdata, ValidityMask &mask,
                                       const SelectionVector *sel, idx_t count, SelectionVector *true_sel,
                                       SelectionVector *false_sel) {
 	idx_t true_count = 0, false_count = 0;
@@ -270,15 +270,15 @@ template <bool NO_NULL>
 static inline idx_t DefaultSelectSwitch(UnifiedVectorFormat &idata, const SelectionVector *sel, idx_t count,
                                         SelectionVector *true_sel, SelectionVector *false_sel) {
 	if (true_sel && false_sel) {
-		return DefaultSelectLoop<NO_NULL, true, true>(idata.sel, (uint8_t *)idata.data, idata.validity, sel, count,
-		                                              true_sel, false_sel);
+		return DefaultSelectLoop<NO_NULL, true, true>(idata.sel, UnifiedVectorFormat::GetData<uint8_t>(idata),
+		                                              idata.validity, sel, count, true_sel, false_sel);
 	} else if (true_sel) {
-		return DefaultSelectLoop<NO_NULL, true, false>(idata.sel, (uint8_t *)idata.data, idata.validity, sel, count,
-		                                               true_sel, false_sel);
+		return DefaultSelectLoop<NO_NULL, true, false>(idata.sel, UnifiedVectorFormat::GetData<uint8_t>(idata),
+		                                               idata.validity, sel, count, true_sel, false_sel);
 	} else {
 		D_ASSERT(false_sel);
-		return DefaultSelectLoop<NO_NULL, false, true>(idata.sel, (uint8_t *)idata.data, idata.validity, sel, count,
-		                                               true_sel, false_sel);
+		return DefaultSelectLoop<NO_NULL, false, true>(idata.sel, UnifiedVectorFormat::GetData<uint8_t>(idata),
+		                                               idata.validity, sel, count, true_sel, false_sel);
 	}
 }
 
@@ -288,7 +288,7 @@ idx_t ExpressionExecutor::DefaultSelect(const Expression &expr, ExpressionState
 	// resolve the true/false expression first
 	// then use that to generate the selection vector
 	bool intermediate_bools[STANDARD_VECTOR_SIZE];
-	Vector intermediate(LogicalType::BOOLEAN, (data_ptr_t)intermediate_bools);
+	Vector intermediate(LogicalType::BOOLEAN, data_ptr_cast(intermediate_bools));
 	Execute(expr, state, sel, count, intermediate);
 
 	UnifiedVectorFormat idata;

package/src/duckdb/src/execution/index/art/art.cpp

@@ -125,7 +125,7 @@ static void TemplatedGenerateKeys(ArenaAllocator &allocator, Vector &input, idx_
 	input.ToUnifiedFormat(count, idata);
 
 	D_ASSERT(keys.size() >= count);
-	auto input_data = (T *)idata.data;
+	auto input_data = UnifiedVectorFormat::GetData<T>(idata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = idata.sel->get_index(i);
 		if (idata.validity.RowIsValid(idx)) {
@@ -142,7 +142,7 @@ static void ConcatenateKeys(ArenaAllocator &allocator, Vector &input, idx_t coun
 	UnifiedVectorFormat idata;
 	input.ToUnifiedFormat(count, idata);
 
-	auto input_data = (T *)idata.data;
+	auto input_data = UnifiedVectorFormat::GetData<T>(idata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = idata.sel->get_index(i);
 
@@ -715,16 +715,16 @@ Node ART::Lookup(Node node, const ARTKey &key, idx_t depth) {
 //          False (Otherwise)
 //===--------------------------------------------------------------------===//
 
-bool ART::SearchGreater(ARTIndexScanState *state, ARTKey &key, bool inclusive, idx_t max_count,
+bool ART::SearchGreater(ARTIndexScanState &state, ARTKey &key, bool inclusive, idx_t max_count,
                         vector<row_t> &result_ids) {
 
-	Iterator *it = &state->iterator;
+	auto &it = state.iterator;
 
 	// greater than scan: first set the iterator to the node at which we will start our scan by finding the lowest node
 	// that satisfies our requirement
-	if (!it->art) {
-		it->art = this;
-		if (!it->LowerBound(*tree, key, inclusive)) {
+	if (!it.art) {
+		it.art = this;
+		if (!it.LowerBound(*tree, key, inclusive)) {
 			return true;
 		}
 	}
@@ -732,74 +732,72 @@ bool ART::SearchGreater(ARTIndexScanState *state, ARTKey &key, bool inclusive, i
 	// after that we continue the scan; we don't need to check the bounds as any value following this value is
 	// automatically bigger and hence satisfies our predicate
 	ARTKey empty_key = ARTKey();
-	return it->Scan(empty_key, max_count, result_ids, false);
+	return it.Scan(empty_key, max_count, result_ids, false);
 }
 
 //===--------------------------------------------------------------------===//
 // Less Than
 //===--------------------------------------------------------------------===//
 
-bool ART::SearchLess(ARTIndexScanState *state, ARTKey &upper_bound, bool inclusive, idx_t max_count,
+bool ART::SearchLess(ARTIndexScanState &state, ARTKey &upper_bound, bool inclusive, idx_t max_count,
                      vector<row_t> &result_ids) {
 
 	if (!tree->IsSet()) {
 		return true;
 	}
 
-	Iterator *it = &state->iterator;
+	auto &it = state.iterator;
 
-	if (!it->art) {
-		it->art = this;
+	if (!it.art) {
+		it.art = this;
 		// first find the minimum value in the ART: we start scanning from this value
-		it->FindMinimum(*tree);
+		it.FindMinimum(*tree);
 		// early out min value higher than upper bound query
-		if (it->cur_key > upper_bound) {
+		if (it.cur_key > upper_bound) {
 			return true;
 		}
 	}
 
 	// now continue the scan until we reach the upper bound
-	return it->Scan(upper_bound, max_count, result_ids, inclusive);
+	return it.Scan(upper_bound, max_count, result_ids, inclusive);
 }
 
 //===--------------------------------------------------------------------===//
 // Closed Range Query
 //===--------------------------------------------------------------------===//
 
-bool ART::SearchCloseRange(ARTIndexScanState *state, ARTKey &lower_bound, ARTKey &upper_bound, bool left_inclusive,
+bool ART::SearchCloseRange(ARTIndexScanState &state, ARTKey &lower_bound, ARTKey &upper_bound, bool left_inclusive,
                            bool right_inclusive, idx_t max_count, vector<row_t> &result_ids) {
-
-	Iterator *it = &state->iterator;
+	auto &it = state.iterator;
 
 	// first find the first node that satisfies the left predicate
-	if (!it->art) {
-		it->art = this;
-		if (!it->LowerBound(*tree, lower_bound, left_inclusive)) {
+	if (!it.art) {
+		it.art = this;
+		if (!it.LowerBound(*tree, lower_bound, left_inclusive)) {
 			return true;
 		}
 	}
 
 	// now continue the scan until we reach the upper bound
-	return it->Scan(upper_bound, max_count, result_ids, right_inclusive);
+	return it.Scan(upper_bound, max_count, result_ids, right_inclusive);
 }
 
 bool ART::Scan(const Transaction &transaction, const DataTable &table, IndexScanState &table_state,
                const idx_t max_count, vector<row_t> &result_ids) {
-
-	auto state = (ARTIndexScanState *)&table_state;
+	auto &state = table_state.Cast<ARTIndexScanState>();
 	vector<row_t> row_ids;
 	bool success;
 
 	// FIXME: the key directly owning the data for a single key might be more efficient
-	D_ASSERT(state->values[0].type().InternalType() == types[0]);
+	D_ASSERT(state.values[0].type().InternalType() == types[0]);
 	ArenaAllocator arena_allocator(Allocator::Get(db));
-	auto key = CreateKey(arena_allocator, types[0], state->values[0]);
+	auto key = CreateKey(arena_allocator, types[0], state.values[0]);
 
-	if (state->values[1].IsNull()) {
+	if (state.values[1].IsNull()) {
 
 		// single predicate
 		lock_guard<mutex> l(lock);
-		switch (state->expressions[0]) {
+		switch (state.expressions[0]) {
 		case ExpressionType::COMPARE_EQUAL:
 			success = SearchEqual(key, max_count, row_ids);
 			break;
@@ -824,11 +822,11 @@ bool ART::Scan(const Transaction &transaction, const DataTable &table, IndexScan
 		// two predicates
 		lock_guard<mutex> l(lock);
 
-		D_ASSERT(state->values[1].type().InternalType() == types[0]);
-		auto upper_bound = CreateKey(arena_allocator, types[0], state->values[1]);
+		D_ASSERT(state.values[1].type().InternalType() == types[0]);
+		auto upper_bound = CreateKey(arena_allocator, types[0], state.values[1]);
 
-		bool left_inclusive = state->expressions[0] == ExpressionType ::COMPARE_GREATERTHANOREQUALTO;
-		bool right_inclusive = state->expressions[1] == ExpressionType ::COMPARE_LESSTHANOREQUALTO;
+		bool left_inclusive = state.expressions[0] == ExpressionType ::COMPARE_GREATERTHANOREQUALTO;
+		bool right_inclusive = state.expressions[1] == ExpressionType ::COMPARE_LESSTHANOREQUALTO;
 		success = SearchCloseRange(state, key, upper_bound, left_inclusive, right_inclusive, max_count, row_ids);
 	}
 

package/src/duckdb/src/execution/index/art/fixed_size_allocator.cpp

@@ -59,7 +59,7 @@ SwizzleablePointer FixedSizeAllocator::New() {
 		buffers_with_free_space.insert(buffer_id);
 
 		// set the bitmask
-		ValidityMask mask((validity_t *)buffer);
+		ValidityMask mask(reinterpret_cast<validity_t *>(buffer));
 		mask.SetAllValid(allocations_per_buffer);
 	}
 
@@ -67,7 +67,7 @@ SwizzleablePointer FixedSizeAllocator::New() {
 	D_ASSERT(!buffers_with_free_space.empty());
 	auto buffer_id = (uint32_t)*buffers_with_free_space.begin();
 
-	auto bitmask_ptr = (validity_t *)buffers[buffer_id].ptr;
+	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffers[buffer_id].ptr);
 	ValidityMask mask(bitmask_ptr);
 	auto offset = GetOffset(mask, buffers[buffer_id].allocation_count);
 
@@ -81,8 +81,7 @@ SwizzleablePointer FixedSizeAllocator::New() {
 }
 
 void FixedSizeAllocator::Free(const SwizzleablePointer ptr) {
-
-	auto bitmask_ptr = (validity_t *)buffers[ptr.buffer_id].ptr;
+	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffers[ptr.buffer_id].ptr);
 	ValidityMask mask(bitmask_ptr);
 	D_ASSERT(!mask.RowIsValid(ptr.offset));
 	mask.SetValid(ptr.offset);

package/src/duckdb/src/execution/join_hashtable.cpp

@@ -102,9 +102,9 @@ void JoinHashTable::ApplyBitmask(Vector &hashes, const SelectionVector &sel, idx
 	UnifiedVectorFormat hdata;
 	hashes.ToUnifiedFormat(count, hdata);
 
-	auto hash_data = (hash_t *)hdata.data;
+	auto hash_data = UnifiedVectorFormat::GetData<hash_t>(hdata);
 	auto result_data = FlatVector::GetData<data_ptr_t *>(pointers);
-	auto main_ht = (data_ptr_t *)hash_map.get();
+	auto main_ht = reinterpret_cast<data_ptr_t *>(hash_map.get());
 	for (idx_t i = 0; i < count; i++) {
 		auto rindex = sel.get_index(i);
 		auto hindex = hdata.sel->get_index(rindex);
@@ -269,7 +269,7 @@ void JoinHashTable::InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_loc
 	hashes.Flatten(count);
 	D_ASSERT(hashes.GetVectorType() == VectorType::FLAT_VECTOR);
 
-	auto pointers = (atomic<data_ptr_t> *)hash_map.get();
+	auto pointers = reinterpret_cast<atomic<data_ptr_t> *>(hash_map.get());
 	auto indices = FlatVector::GetData<hash_t>(hashes);
 
 	if (parallel) {
@@ -300,7 +300,7 @@ void JoinHashTable::InitializePointerTable() {
 	D_ASSERT(hash_map.GetSize() == capacity * sizeof(data_ptr_t));
 
 	// initialize HT with all-zero entries
-	std::fill_n((data_ptr_t *)hash_map.get(), capacity, nullptr);
+	std::fill_n(reinterpret_cast<data_ptr_t *>(hash_map.get()), capacity, nullptr);
 
 	bitmask = capacity - 1;
 }

package/src/duckdb/src/execution/nested_loop_join/nested_loop_join_inner.cpp

@@ -24,8 +24,8 @@ struct InitialNestedLoopJoin {
 		left.ToUnifiedFormat(left_size, left_data);
 		right.ToUnifiedFormat(right_size, right_data);
 
-		auto ldata = (T *)left_data.data;
-		auto rdata = (T *)right_data.data;
+		auto ldata = UnifiedVectorFormat::GetData<T>(left_data);
+		auto rdata = UnifiedVectorFormat::GetData<T>(right_data);
 		idx_t result_count = 0;
 		for (; rpos < right_size; rpos++) {
 			idx_t right_position = right_data.sel->get_index(rpos);
@@ -62,8 +62,8 @@ struct RefineNestedLoopJoin {
 		// refine lvector and rvector based on matches of subsequent conditions (in case there are multiple conditions
 		// in the join)
 		D_ASSERT(current_match_count > 0);
-		auto ldata = (T *)left_data.data;
-		auto rdata = (T *)right_data.data;
+		auto ldata = UnifiedVectorFormat::GetData<T>(left_data);
+		auto rdata = UnifiedVectorFormat::GetData<T>(right_data);
 		idx_t result_count = 0;
 		for (idx_t i = 0; i < current_match_count; i++) {
 			auto lidx = lvector.get_index(i);

package/src/duckdb/src/execution/nested_loop_join/nested_loop_join_mark.cpp

@@ -10,8 +10,8 @@ static void TemplatedMarkJoin(Vector &left, Vector &right, idx_t lcount, idx_t r
 	left.ToUnifiedFormat(lcount, left_data);
 	right.ToUnifiedFormat(rcount, right_data);
 
-	auto ldata = (T *)left_data.data;
-	auto rdata = (T *)right_data.data;
+	auto ldata = UnifiedVectorFormat::GetData<T>(left_data);
+	auto rdata = UnifiedVectorFormat::GetData<T>(right_data);
 	for (idx_t i = 0; i < lcount; i++) {
 		if (found_match[i]) {
 			continue;

package/src/duckdb/src/execution/operator/aggregate/distinct_aggregate_data.cpp

@@ -124,7 +124,7 @@ struct FindMatchingAggregate {
 		if (other.children.size() != aggr.children.size()) {
 			return false;
 		}
-		if (!Expression::Equals(aggr.filter.get(), other.filter.get())) {
+		if (!Expression::Equals(aggr.filter, other.filter)) {
 			return false;
 		}
 		for (idx_t i = 0; i < aggr.children.size(); i++) {

package/src/duckdb/src/execution/operator/aggregate/physical_perfecthash_aggregate.cpp

@@ -186,7 +186,7 @@ unique_ptr<GlobalSourceState> PhysicalPerfectHashAggregate::GetGlobalSourceState
 
 SourceResultType PhysicalPerfectHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk,
                                                        OperatorSourceInput &input) const {
-	auto &state = (PerfectHashAggregateState &)input.global_state;
+	auto &state = input.global_state.Cast<PerfectHashAggregateState>();
 	auto &gstate = sink_state->Cast<PerfectHashAggregateGlobalState>();
 
 	gstate.ht->Scan(state.ht_scan_position, chunk);

package/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp

@@ -26,7 +26,7 @@ class StreamingWindowState : public OperatorState {
 public:
 	using StateBuffer = vector<data_t>;
 
-	StreamingWindowState() : initialized(false), statev(LogicalType::POINTER, (data_ptr_t)&state_ptr) {
+	StreamingWindowState() : initialized(false), statev(LogicalType::POINTER, data_ptr_cast(&state_ptr)) {
 	}
 
 	~StreamingWindowState() override {
@@ -109,7 +109,7 @@ unique_ptr<OperatorState> PhysicalStreamingWindow::GetOperatorState(ExecutionCon
 OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                     GlobalOperatorState &gstate_p, OperatorState &state_p) const {
 	auto &gstate = gstate_p.Cast<StreamingWindowGlobalState>();
-	auto &state = (StreamingWindowState &)state_p;
+	auto &state = state_p.Cast<StreamingWindowState>();
 	if (!state.initialized) {
 		state.Initialize(context.client, input, select_list);
 	}

package/src/duckdb/src/execution/operator/aggregate/physical_ungrouped_aggregate.cpp

@@ -55,7 +55,7 @@ struct AggregateState {
 			if (!destructors[i]) {
 				continue;
 			}
-			Vector state_vector(Value::POINTER((uintptr_t)aggregates[i].get()));
+			Vector state_vector(Value::POINTER(CastPointerToValue(aggregates[i].get())));
 			state_vector.SetVectorType(VectorType::FLAT_VECTOR);
 
 			AggregateInputData aggr_input_data(bind_data[i], Allocator::DefaultAllocator());
@@ -332,8 +332,8 @@ void PhysicalUngroupedAggregate::Combine(ExecutionContext &context, GlobalSinkSt
 			continue;
 		}
 
-		Vector source_state(Value::POINTER((uintptr_t)source.state.aggregates[aggr_idx].get()));
-		Vector dest_state(Value::POINTER((uintptr_t)gstate.state.aggregates[aggr_idx].get()));
+		Vector source_state(Value::POINTER(CastPointerToValue(source.state.aggregates[aggr_idx].get())));
+		Vector dest_state(Value::POINTER(CastPointerToValue(gstate.state.aggregates[aggr_idx].get())));
 
 		AggregateInputData aggr_input_data(aggregate.bind_info.get(), Allocator::DefaultAllocator());
 		aggregate.function.combine(source_state, dest_state, aggr_input_data, 1);
@@ -565,7 +565,7 @@ SourceResultType PhysicalUngroupedAggregate::GetData(ExecutionContext &context,
 	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
 		auto &aggregate = aggregates[aggr_idx]->Cast<BoundAggregateExpression>();
 
-		Vector state_vector(Value::POINTER((uintptr_t)gstate.state.aggregates[aggr_idx].get()));
+		Vector state_vector(Value::POINTER(CastPointerToValue(gstate.state.aggregates[aggr_idx].get())));
 		AggregateInputData aggr_input_data(aggregate.bind_info.get(), Allocator::DefaultAllocator());
 		aggregate.function.finalize(state_vector, aggr_input_data, chunk.data[aggr_idx], 1, 0);
 	}

package/src/duckdb/src/execution/operator/filter/physical_filter.cpp

@@ -41,7 +41,7 @@ unique_ptr<OperatorState> PhysicalFilter::GetOperatorState(ExecutionContext &con
 
 OperatorResultType PhysicalFilter::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                    GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (FilterState &)state_p;
+	auto &state = state_p.Cast<FilterState>();
 	idx_t result_count = state.executor.SelectExpression(input, state.sel);
 	if (result_count == input.size()) {
 		// nothing was filtered: skip adding any selection vectors

package/src/duckdb/src/execution/operator/join/outer_join_marker.cpp

@@ -63,7 +63,7 @@ void OuterJoinMarker::ConstructLeftJoinResult(DataChunk &left, DataChunk &result
 }
 
 idx_t OuterJoinMarker::MaxThreads() const {
-	return count / (STANDARD_VECTOR_SIZE * 10);
+	return count / (STANDARD_VECTOR_SIZE * 10ULL);
 }
 
 void OuterJoinMarker::InitializeScan(ColumnDataCollection &data, OuterJoinGlobalScanState &gstate) {

package/src/duckdb/src/execution/operator/join/perfect_hash_join_executor.cpp

@@ -168,7 +168,7 @@ unique_ptr<OperatorState> PerfectHashJoinExecutor::GetOperatorState(ExecutionCon
 
 OperatorResultType PerfectHashJoinExecutor::ProbePerfectHashTable(ExecutionContext &context, DataChunk &input,
                                                                   DataChunk &result, OperatorState &state_p) {
-	auto &state = (PerfectHashJoinState &)state_p;
+	auto &state = state_p.Cast<PerfectHashJoinState>();
 	// keeps track of how many probe keys have a match
 	idx_t probe_sel_count = 0;
 

package/src/duckdb/src/execution/operator/join/physical_asof_join.cpp

@@ -305,7 +305,7 @@ void AsOfLocalState::ResolveJoinKeys(DataChunk &input) {
 
 	DataChunk payload_chunk;
 	payload_chunk.InitializeEmpty({LogicalType::UINTEGER});
-	FlatVector::SetData(payload_chunk.data[0], (data_ptr_t)lhs_sel.data());
+	FlatVector::SetData(payload_chunk.data[0], data_ptr_cast(lhs_sel.data()));
 	payload_chunk.SetCardinality(lhs_valid);
 	local_sort.SinkChunk(lhs_keys, payload_chunk);
 
@@ -338,7 +338,7 @@ void AsOfLocalState::ResolveJoin(DataChunk &input, bool *found_match, std::pair<
 	// But they may be constant, so unify.
 	UnifiedVectorFormat bin_unified;
 	bin_vector.ToUnifiedFormat(lhs_valid, bin_unified);
-	const auto bins = (hash_t *)bin_unified.data;
+	const auto bins = UnifiedVectorFormat::GetData<hash_t>(bin_unified);
 
 	hash_t prev_bin = global_partition.bin_groups.size();
 	optional_ptr<PartitionGlobalHashGroup> hash_group;

package/src/duckdb/src/execution/operator/join/physical_blockwise_nl_join.cpp

@@ -111,7 +111,7 @@ OperatorResultType PhysicalBlockwiseNLJoin::ExecuteInternal(ExecutionContext &co
                                                             DataChunk &chunk, GlobalOperatorState &gstate_p,
                                                             OperatorState &state_p) const {
 	D_ASSERT(input.size() > 0);
-	auto &state = (BlockwiseNLJoinState &)state_p;
+	auto &state = state_p.Cast<BlockwiseNLJoinState>();
 	auto &gstate = sink_state->Cast<BlockwiseNLJoinGlobalState>();
 
 	if (gstate.right_chunks.Count() == 0) {
@@ -244,7 +244,7 @@ unique_ptr<GlobalSourceState> PhysicalBlockwiseNLJoin::GetGlobalSourceState(Clie
 
 unique_ptr<LocalSourceState> PhysicalBlockwiseNLJoin::GetLocalSourceState(ExecutionContext &context,
                                                                           GlobalSourceState &gstate) const {
-	return make_uniq<BlockwiseNLJoinLocalScanState>(*this, (BlockwiseNLJoinGlobalScanState &)gstate);
+	return make_uniq<BlockwiseNLJoinLocalScanState>(*this, gstate.Cast<BlockwiseNLJoinGlobalScanState>());
 }
 
 SourceResultType PhysicalBlockwiseNLJoin::GetData(ExecutionContext &context, DataChunk &chunk,
@@ -252,8 +252,8 @@ SourceResultType PhysicalBlockwiseNLJoin::GetData(ExecutionContext &context, Dat
 	D_ASSERT(IsRightOuterJoin(join_type));
 	// check if we need to scan any unmatched tuples from the RHS for the full/right outer join
 	auto &sink = sink_state->Cast<BlockwiseNLJoinGlobalState>();
-	auto &gstate = (BlockwiseNLJoinGlobalScanState &)input.global_state;
-	auto &lstate = (BlockwiseNLJoinLocalScanState &)input.local_state;
+	auto &gstate = input.global_state.Cast<BlockwiseNLJoinGlobalScanState>();
+	auto &lstate = input.local_state.Cast<BlockwiseNLJoinLocalScanState>();
 
 	// if the LHS is exhausted in a FULL/RIGHT OUTER JOIN, we scan chunks we still need to output
 	sink.right_outer.Scan(gstate.scan_state, lstate.scan_state, chunk);

package/src/duckdb/src/execution/operator/join/physical_index_join.cpp

@@ -67,7 +67,7 @@ PhysicalIndexJoin::PhysicalIndexJoin(LogicalOperator &op, unique_ptr<PhysicalOpe
       left_projection_map(left_projection_map_p), right_projection_map(std::move(right_projection_map_p)),
       index(index_p), conditions(std::move(cond)), join_type(join_type), lhs_first(lhs_first) {
 	D_ASSERT(right->type == PhysicalOperatorType::TABLE_SCAN);
-	auto &tbl_scan = (PhysicalTableScan &)*right;
+	auto &tbl_scan = right->Cast<PhysicalTableScan>();
 	column_ids = std::move(column_ids_p);
 	children.push_back(std::move(left));
 	children.push_back(std::move(right));
@@ -109,7 +109,7 @@ unique_ptr<OperatorState> PhysicalIndexJoin::GetOperatorState(ExecutionContext &
 
 void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                OperatorState &state_p) const {
-	auto &phy_tbl_scan = (PhysicalTableScan &)*children[1];
+	auto &phy_tbl_scan = children[1]->Cast<PhysicalTableScan>();
 	auto &bind_tbl = phy_tbl_scan.bind_data->Cast<TableScanBindData>();
 	auto &transaction = DuckTransaction::Get(context.client, bind_tbl.table.catalog);
 	auto &state = state_p.Cast<IndexJoinOperatorState>();
@@ -139,7 +139,7 @@ void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, Data
 		}
 		state.rhs_chunk.Reset();
 		state.fetch_state = make_uniq<ColumnFetchState>();
-		Vector row_ids(LogicalType::ROW_TYPE, (data_ptr_t)&fetch_rows[0]);
+		Vector row_ids(LogicalType::ROW_TYPE, data_ptr_cast(&fetch_rows[0]));
 		tbl.Fetch(transaction, state.rhs_chunk, fetch_ids, row_ids, output_sel_idx, *state.fetch_state);
 	}