duckdb 0.8.1-dev31.0 → 0.8.1-dev341.0

package/src/duckdb/src/core_functions/scalar/list/list_lambdas.cpp

@@ -40,7 +40,7 @@ unique_ptr<FunctionData> ListLambdaBindData::Copy() const {
 
 bool ListLambdaBindData::Equals(const FunctionData &other_p) const {
 	auto &other = other_p.Cast<ListLambdaBindData>();
-	return lambda_expr->Equals(other.lambda_expr.get()) && stype == other.stype;
+	return lambda_expr->Equals(*other.lambda_expr) && stype == other.stype;
 }
 
 ListLambdaBindData::~ListLambdaBindData() {
@@ -63,7 +63,7 @@ static void AppendFilteredToResult(Vector &lambda_vector, list_entry_t *result_e
 	UnifiedVectorFormat lambda_data;
 	lambda_vector.ToUnifiedFormat(elem_cnt, lambda_data);
 
-	auto lambda_values = (bool *)lambda_data.data;
+	auto lambda_values = UnifiedVectorFormat::GetData<bool>(lambda_data);
 	auto &lambda_validity = lambda_data.validity;
 
 	// compute the new lengths and offsets, and create a selection vector
@@ -167,7 +167,7 @@ static void ListLambdaFunction(DataChunk &args, ExpressionState &state, Vector &
 	// get the lists data
 	UnifiedVectorFormat lists_data;
 	lists.ToUnifiedFormat(count, lists_data);
-	auto list_entries = (list_entry_t *)lists_data.data;
+	auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(lists_data);
 
 	// get the lambda expression
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
@@ -321,8 +321,7 @@ static void ListFilterFunction(DataChunk &args, ExpressionState &state, Vector &
 template <int64_t LAMBDA_PARAM_CNT>
 static unique_ptr<FunctionData> ListLambdaBind(ClientContext &context, ScalarFunction &bound_function,
                                                vector<unique_ptr<Expression>> &arguments) {
-
-	auto &bound_lambda_expr = (BoundLambdaExpression &)*arguments[1];
+	auto &bound_lambda_expr = arguments[1]->Cast<BoundLambdaExpression>();
 	if (bound_lambda_expr.parameter_count != LAMBDA_PARAM_CNT) {
 		throw BinderException("Incorrect number of parameters in lambda function! " + bound_function.name +
 		                      " expects " + to_string(LAMBDA_PARAM_CNT) + " parameter(s).");
@@ -355,7 +354,7 @@ static unique_ptr<FunctionData> ListTransformBind(ClientContext &context, Scalar
 		throw BinderException("Invalid lambda expression!");
 	}
 
-	auto &bound_lambda_expr = (BoundLambdaExpression &)*arguments[1];
+	auto &bound_lambda_expr = arguments[1]->Cast<BoundLambdaExpression>();
 	bound_function.return_type = LogicalType::LIST(bound_lambda_expr.lambda_expr->return_type);
 	return ListLambdaBind<1>(context, bound_function, arguments);
 }
@@ -370,7 +369,7 @@ static unique_ptr<FunctionData> ListFilterBind(ClientContext &context, ScalarFun
 	}
 
 	// try to cast to boolean, if the return type of the lambda filter expression is not already boolean
-	auto &bound_lambda_expr = (BoundLambdaExpression &)*arguments[1];
+	auto &bound_lambda_expr = arguments[1]->Cast<BoundLambdaExpression>();
 	if (bound_lambda_expr.lambda_expr->return_type != LogicalType::BOOLEAN) {
 		auto cast_lambda_expr =
 		    BoundCastExpression::AddCastToType(context, std::move(bound_lambda_expr.lambda_expr), LogicalType::BOOLEAN);

package/src/duckdb/src/core_functions/scalar/list/list_sort.cpp

@@ -132,7 +132,7 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 	// get the lists data
 	UnifiedVectorFormat lists_data;
 	result.ToUnifiedFormat(count, lists_data);
-	auto list_entries = (list_entry_t *)lists_data.data;
+	auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(lists_data);
 
 	// create the lists_indices vector, this contains an element for each list's entry,
 	// the element corresponds to the list's index, e.g. for [1, 2, 4], [5, 4]

package/src/duckdb/src/core_functions/scalar/map/cardinality.cpp

@@ -16,7 +16,7 @@ static void CardinalityFunction(DataChunk &args, ExpressionState &state, Vector
 
 	map.ToUnifiedFormat(args.size(), map_data);
 	for (idx_t row = 0; row < args.size(); row++) {
-		auto list_entry = ((list_entry_t *)map_data.data)[map_data.sel->get_index(row)];
+		auto list_entry = UnifiedVectorFormat::GetData<list_entry_t>(map_data)[map_data.sel->get_index(row)];
 		result_data[row] = list_entry.length;
 		result_validity.Set(row, map_data.validity.RowIsValid(map_data.sel->get_index(row)));
 	}

package/src/duckdb/src/core_functions/scalar/map/map.cpp

@@ -55,8 +55,8 @@ static bool ListEntriesEqual(Vector &keys, Vector &values, idx_t count) {
 	keys.ToUnifiedFormat(count, keys_data);
 	values.ToUnifiedFormat(count, values_data);
 
-	auto keys_entries = (list_entry_t *)keys_data.data;
-	auto values_entries = (list_entry_t *)values_data.data;
+	auto keys_entries = UnifiedVectorFormat::GetData<list_entry_t>(keys_data);
+	auto values_entries = UnifiedVectorFormat::GetData<list_entry_t>(values_data);
 
 	if (same_vector_type) {
 		const auto key_data = keys_data.data;

package/src/duckdb/src/core_functions/scalar/map/map_concat.cpp

@@ -69,7 +69,7 @@ static void MapConcatFunction(DataChunk &args, ExpressionState &state, Vector &r
 			auto &keys = MapVector::GetKeys(args.data[map_idx]);
 
 			auto index = map_format.sel->get_index(i);
-			auto entry = ((list_entry_t *)map_format.data)[index];
+			auto entry = UnifiedVectorFormat::GetData<list_entry_t>(map_format)[index];
 
 			// Update the list for this row
 			for (idx_t list_idx = 0; list_idx < entry.length; list_idx++) {
@@ -153,6 +153,9 @@ static unique_ptr<FunctionData> MapConcatBind(ClientContext &context, ScalarFunc
 			// The maps are allowed to be NULL
 			continue;
 		}
+		if (map.id() != LogicalTypeId::MAP) {
+			throw InvalidInputException("MAP_CONCAT only takes map arguments");
+		}
 		is_null = false;
 		if (IsEmptyMap(map)) {
 			// Map is allowed to be empty

package/src/duckdb/src/core_functions/scalar/map/map_extract.cpp

@@ -30,9 +30,7 @@ void FillResult(Vector &map, Vector &offsets, Vector &result, idx_t count) {
 	UnifiedVectorFormat offset_data;
 	offsets.ToUnifiedFormat(count, offset_data);
 
-	UnifiedVectorFormat result_data;
-	result.ToUnifiedFormat(count, result_data);
-
+	auto result_data = FlatVector::GetData<list_entry_t>(result);
 	auto entry_count = ListVector::GetListSize(map);
 	auto &values_entries = MapVector::GetValues(map);
 	UnifiedVectorFormat values_entry_data;
@@ -41,14 +39,13 @@ void FillResult(Vector &map, Vector &offsets, Vector &result, idx_t count) {
 
 	for (idx_t row = 0; row < count; row++) {
 		idx_t offset_idx = offset_data.sel->get_index(row);
-		auto offset = ((int32_t *)offset_data.data)[offset_idx];
+		auto offset = UnifiedVectorFormat::GetData<int32_t>(offset_data)[offset_idx];
 
 		// Get the current size of the list, for the offset
 		idx_t current_offset = ListVector::GetListSize(result);
 		if (!offset_data.validity.RowIsValid(offset_idx) || !offset) {
 			// Set the entry data for this result row
-			idx_t result_index = result_data.sel->get_index(row);
-			auto &entry = ((list_entry_t *)result_data.data)[result_index];
+			auto &entry = result_data[row];
 			entry.length = 0;
 			entry.offset = current_offset;
 			continue;
@@ -58,7 +55,7 @@ void FillResult(Vector &map, Vector &offsets, Vector &result, idx_t count) {
 
 		// Get the 'values' list entry corresponding to the offset
 		idx_t value_index = map_data.sel->get_index(row);
-		auto &value_list_entry = ((list_entry_t *)map_data.data)[value_index];
+		auto &value_list_entry = UnifiedVectorFormat::GetData<list_entry_t>(map_data)[value_index];
 
 		// Add the values to the result
 		idx_t list_offset = value_list_entry.offset + offset;
@@ -67,8 +64,7 @@ void FillResult(Vector &map, Vector &offsets, Vector &result, idx_t count) {
 		ListVector::Append(result, values_entries, length + list_offset, list_offset);
 
 		// Set the entry data for this result row
-		idx_t result_index = result_data.sel->get_index(row);
-		auto &entry = ((list_entry_t *)result_data.data)[result_index];
+		auto &entry = result_data[row];
 		entry.length = length;
 		entry.offset = current_offset;
 	}

package/src/duckdb/src/core_functions/scalar/math/numeric.cpp

@@ -563,7 +563,7 @@ struct RoundPrecisionFunctionData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const RoundPrecisionFunctionData &)other_p;
+		auto &other = other_p.Cast<RoundPrecisionFunctionData>();
 		return target_scale == other.target_scale;
 	}
 };
@@ -571,7 +571,7 @@ struct RoundPrecisionFunctionData : public FunctionData {
 template <class T, class POWERS_OF_TEN_CLASS>
 static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = (RoundPrecisionFunctionData &)*func_expr.bind_info;
+	auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
 	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
 	auto width = DecimalType::GetWidth(func_expr.children[0]->return_type);
 	if (-info.target_scale >= width) {
@@ -597,7 +597,7 @@ static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionSt
 template <class T, class POWERS_OF_TEN_CLASS>
 static void DecimalRoundPositivePrecisionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	auto &info = (RoundPrecisionFunctionData &)*func_expr.bind_info;
+	auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
 	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
 	T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[source_scale - info.target_scale];
 	T addition = power_of_ten / 2;

package/src/duckdb/src/core_functions/scalar/string/starts_with.cpp

@@ -17,9 +17,10 @@ static bool StartsWith(const unsigned char *haystack, idx_t haystack_size, const
 }
 
 static bool StartsWith(const string_t &haystack_s, const string_t &needle_s) {
-	auto haystack = (const unsigned char *)haystack_s.GetData();
+
+	auto haystack = const_uchar_ptr_cast(haystack_s.GetData());
 	auto haystack_size = haystack_s.GetSize();
-	auto needle = (const unsigned char *)needle_s.GetData();
+	auto needle = const_uchar_ptr_cast(needle_s.GetData());
 	auto needle_size = needle_s.GetSize();
 	if (needle_size == 0) {
 		// empty needle: always true

package/src/duckdb/src/core_functions/scalar/string/string_split.cpp

@@ -36,7 +36,7 @@ struct RegularStringSplit {
 		if (delim_size == 0) {
 			return 0;
 		}
-		return ContainsFun::Find((const unsigned char *)input_data, input_size, (const unsigned char *)delim_data,
+		return ContainsFun::Find(const_uchar_ptr_cast(input_data), input_size, const_uchar_ptr_cast(delim_data),
 		                         delim_size);
 	}
 };
@@ -45,7 +45,7 @@ struct ConstantRegexpStringSplit {
 	static idx_t Find(const char *input_data, idx_t input_size, const char *delim_data, idx_t delim_size,
 	                  idx_t &match_size, void *data) {
 		D_ASSERT(data);
-		auto regex = (duckdb_re2::RE2 *)data;
+		auto regex = reinterpret_cast<duckdb_re2::RE2 *>(data);
 		duckdb_re2::StringPiece match;
 		if (!regex->Match(duckdb_re2::StringPiece(input_data, input_size), 0, input_size, RE2::UNANCHORED, &match, 1)) {
 			return DConstants::INVALID_INDEX;
@@ -109,11 +109,11 @@ template <class OP>
 static void StringSplitExecutor(DataChunk &args, ExpressionState &state, Vector &result, void *data = nullptr) {
 	UnifiedVectorFormat input_data;
 	args.data[0].ToUnifiedFormat(args.size(), input_data);
-	auto inputs = (string_t *)input_data.data;
+	auto inputs = UnifiedVectorFormat::GetData<string_t>(input_data);
 
 	UnifiedVectorFormat delim_data;
 	args.data[1].ToUnifiedFormat(args.size(), delim_data);
-	auto delims = (string_t *)delim_data.data;
+	auto delims = UnifiedVectorFormat::GetData<string_t>(delim_data);
 
 	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
 

package/src/duckdb/src/core_functions/scalar/string/trim.cpp

@@ -64,7 +64,7 @@ static void UnaryTrimFunction(DataChunk &args, ExpressionState &state, Vector &r
 }
 
 static void GetIgnoredCodepoints(string_t ignored, unordered_set<utf8proc_int32_t> &ignored_codepoints) {
-	auto dataptr = (utf8proc_uint8_t *)ignored.GetData();
+	auto dataptr = reinterpret_cast<const utf8proc_uint8_t *>(ignored.GetData());
 	auto size = ignored.GetSize();
 	idx_t pos = 0;
 	while (pos < size) {

package/src/duckdb/src/core_functions/scalar/union/union_extract.cpp

@@ -20,7 +20,7 @@ public:
 		return make_uniq<UnionExtractBindData>(key, index, type);
 	}
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const UnionExtractBindData &)other_p;
+		auto &other = other_p.Cast<UnionExtractBindData>();
 		return key == other.key && index == other.index && type == other.type;
 	}
 };

package/src/duckdb/src/execution/adaptive_filter.cpp

@@ -7,7 +7,7 @@ namespace duckdb {
 
 AdaptiveFilter::AdaptiveFilter(const Expression &expr)
     : iteration_count(0), observe_interval(10), execute_interval(20), warmup(true) {
-	auto &conj_expr = (const BoundConjunctionExpression &)expr;
+	auto &conj_expr = expr.Cast<BoundConjunctionExpression>();
 	D_ASSERT(conj_expr.children.size() > 1);
 	for (idx_t idx = 0; idx < conj_expr.children.size(); idx++) {
 		permutation.push_back(idx);

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;