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

package/src/duckdb/src/core_functions/scalar/date/date_part.cpp

@@ -521,8 +521,9 @@ struct DatePart {
 		}
 
 		template <typename P>
-		static inline P HasPartValue(P *part_values, DatePartSpecifier part) {
-			return part_values[int(part)];
+		static inline bool HasPartValue(P *part_values, DatePartSpecifier part, P &value) {
+			value = part_values[int(part)];
+			return value;
 		}
 
 		template <class TA, class TR>
@@ -534,28 +535,28 @@ struct DatePart {
 			int32_t dd = 1;
 			if (mask & YMD) {
 				Date::Convert(input, yyyy, mm, dd);
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::YEAR))) {
+				if (HasPartValue(part_values, DatePartSpecifier::YEAR, part_data)) {
 					part_data[idx] = yyyy;
 				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::MONTH))) {
+				if (HasPartValue(part_values, DatePartSpecifier::MONTH, part_data)) {
 					part_data[idx] = mm;
 				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DAY))) {
+				if (HasPartValue(part_values, DatePartSpecifier::DAY, part_data)) {
 					part_data[idx] = dd;
 				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DECADE))) {
+				if (HasPartValue(part_values, DatePartSpecifier::DECADE, part_data)) {
 					part_data[idx] = DecadeOperator::DecadeFromYear(yyyy);
 				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::CENTURY))) {
+				if (HasPartValue(part_values, DatePartSpecifier::CENTURY, part_data)) {
 					part_data[idx] = CenturyOperator::CenturyFromYear(yyyy);
 				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::MILLENNIUM))) {
+				if (HasPartValue(part_values, DatePartSpecifier::MILLENNIUM, part_data)) {
 					part_data[idx] = MillenniumOperator::MillenniumFromYear(yyyy);
 				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::QUARTER))) {
+				if (HasPartValue(part_values, DatePartSpecifier::QUARTER, part_data)) {
 					part_data[idx] = QuarterOperator::QuarterFromMonth(mm);
 				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::ERA))) {
+				if (HasPartValue(part_values, DatePartSpecifier::ERA, part_data)) {
 					part_data[idx] = EraOperator::EraFromYear(yyyy);
 				}
 			}
@@ -563,10 +564,10 @@ struct DatePart {
 			// Week calculations
 			if (mask & DOW) {
 				auto isodow = Date::ExtractISODayOfTheWeek(input);
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DOW))) {
+				if (HasPartValue(part_values, DatePartSpecifier::DOW, part_data)) {
 					part_data[idx] = DayOfWeekOperator::DayOfWeekFromISO(isodow);
 				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::ISODOW))) {
+				if (HasPartValue(part_values, DatePartSpecifier::ISODOW, part_data)) {
 					part_data[idx] = isodow;
 				}
 			}
@@ -576,24 +577,24 @@ struct DatePart {
 				int32_t ww = 0;
 				int32_t iyyy = 0;
 				Date::ExtractISOYearWeek(input, iyyy, ww);
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::WEEK))) {
+				if (HasPartValue(part_values, DatePartSpecifier::WEEK, part_data)) {
 					part_data[idx] = ww;
 				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::ISOYEAR))) {
+				if (HasPartValue(part_values, DatePartSpecifier::ISOYEAR, part_data)) {
 					part_data[idx] = iyyy;
 				}
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::YEARWEEK))) {
+				if (HasPartValue(part_values, DatePartSpecifier::YEARWEEK, part_data)) {
 					part_data[idx] = YearWeekOperator::YearWeekFromParts(iyyy, ww);
 				}
 			}
 
 			if (mask & EPOCH) {
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH))) {
+				if (HasPartValue(part_values, DatePartSpecifier::EPOCH, part_data)) {
 					part_data[idx] = Date::Epoch(input);
 				}
 			}
 			if (mask & DOY) {
-				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DOY))) {
+				if (HasPartValue(part_values, DatePartSpecifier::DOY, part_data)) {
 					part_data[idx] = Date::ExtractDayOfTheYear(input);
 				}
 			}
@@ -948,38 +949,37 @@ void DatePart::StructOperator::Operation(int64_t **part_values, const dtime_t &i
 	int64_t *part_data;
 	if (mask & TIME) {
 		const auto micros = MicrosecondsOperator::Operation<dtime_t, int64_t>(input);
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MICROSECONDS))) {
+		if (HasPartValue(part_values, DatePartSpecifier::MICROSECONDS, part_data)) {
 			part_data[idx] = micros;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MILLISECONDS))) {
+		if (HasPartValue(part_values, DatePartSpecifier::MILLISECONDS, part_data)) {
 			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::SECOND))) {
+		if (HasPartValue(part_values, DatePartSpecifier::SECOND, part_data)) {
 			part_data[idx] = micros / Interval::MICROS_PER_SEC;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MINUTE))) {
+		if (HasPartValue(part_values, DatePartSpecifier::MINUTE, part_data)) {
 			part_data[idx] = MinutesOperator::Operation<dtime_t, int64_t>(input);
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::HOUR))) {
+		if (HasPartValue(part_values, DatePartSpecifier::HOUR, part_data)) {
 			part_data[idx] = HoursOperator::Operation<dtime_t, int64_t>(input);
 		}
 	}
 
 	if (mask & EPOCH) {
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH))) {
+		if (HasPartValue(part_values, DatePartSpecifier::EPOCH, part_data)) {
 			part_data[idx] = EpochOperator::Operation<dtime_t, int64_t>(input);
-			;
 		}
 	}
 
 	if (mask & ZONE) {
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE))) {
+		if (HasPartValue(part_values, DatePartSpecifier::TIMEZONE, part_data)) {
 			part_data[idx] = 0;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE_HOUR))) {
+		if (HasPartValue(part_values, DatePartSpecifier::TIMEZONE_HOUR, part_data)) {
 			part_data[idx] = 0;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE_MINUTE))) {
+		if (HasPartValue(part_values, DatePartSpecifier::TIMEZONE_MINUTE, part_data)) {
 			part_data[idx] = 0;
 		}
 	}
@@ -998,8 +998,8 @@ void DatePart::StructOperator::Operation(int64_t **part_values, const timestamp_
 	Operation(part_values, t, idx, mask & ~EPOCH);
 
 	if (mask & EPOCH) {
-		auto part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH);
-		if (part_data) {
+		int64_t *part_data;
+		if (HasPartValue(part_values, DatePartSpecifier::EPOCH, part_data)) {
 			part_data[idx] = EpochOperator::Operation<timestamp_t, int64_t>(input);
 		}
 	}
@@ -1011,50 +1011,50 @@ void DatePart::StructOperator::Operation(int64_t **part_values, const interval_t
 	int64_t *part_data;
 	if (mask & YMD) {
 		const auto mm = input.months % Interval::MONTHS_PER_YEAR;
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::YEAR))) {
+		if (HasPartValue(part_values, DatePartSpecifier::YEAR, part_data)) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_YEAR;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MONTH))) {
+		if (HasPartValue(part_values, DatePartSpecifier::MONTH, part_data)) {
 			part_data[idx] = mm;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::DAY))) {
+		if (HasPartValue(part_values, DatePartSpecifier::DAY, part_data)) {
 			part_data[idx] = input.days;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::DECADE))) {
+		if (HasPartValue(part_values, DatePartSpecifier::DECADE, part_data)) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_DECADE;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::CENTURY))) {
+		if (HasPartValue(part_values, DatePartSpecifier::CENTURY, part_data)) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_CENTURY;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MILLENNIUM))) {
+		if (HasPartValue(part_values, DatePartSpecifier::MILLENNIUM, part_data)) {
 			part_data[idx] = input.months / Interval::MONTHS_PER_MILLENIUM;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::QUARTER))) {
+		if (HasPartValue(part_values, DatePartSpecifier::QUARTER, part_data)) {
 			part_data[idx] = mm / Interval::MONTHS_PER_QUARTER + 1;
 		}
 	}
 
 	if (mask & TIME) {
 		const auto micros = MicrosecondsOperator::Operation<interval_t, int64_t>(input);
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MICROSECONDS))) {
+		if (HasPartValue(part_values, DatePartSpecifier::MICROSECONDS, part_data)) {
 			part_data[idx] = micros;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MILLISECONDS))) {
+		if (HasPartValue(part_values, DatePartSpecifier::MILLISECONDS, part_data)) {
 			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::SECOND))) {
+		if (HasPartValue(part_values, DatePartSpecifier::SECOND, part_data)) {
 			part_data[idx] = micros / Interval::MICROS_PER_SEC;
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MINUTE))) {
+		if (HasPartValue(part_values, DatePartSpecifier::MINUTE, part_data)) {
 			part_data[idx] = MinutesOperator::Operation<interval_t, int64_t>(input);
 		}
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::HOUR))) {
+		if (HasPartValue(part_values, DatePartSpecifier::HOUR, part_data)) {
 			part_data[idx] = HoursOperator::Operation<interval_t, int64_t>(input);
 		}
 	}
 
 	if (mask & EPOCH) {
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH))) {
+		if (HasPartValue(part_values, DatePartSpecifier::EPOCH, part_data)) {
 			part_data[idx] = EpochOperator::Operation<interval_t, int64_t>(input);
 		}
 	}
@@ -1264,7 +1264,7 @@ struct StructDatePart {
 	template <typename INPUT_TYPE>
 	static void Function(DataChunk &args, ExpressionState &state, Vector &result) {
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = (BindData &)*func_expr.bind_info;
+		auto &info = func_expr.bind_info->Cast<BindData>();
 		D_ASSERT(args.ColumnCount() == 1);
 
 		const auto count = args.size();
@@ -1313,7 +1313,7 @@ struct StructDatePart {
 			input.ToUnifiedFormat(count, rdata);
 
 			const auto &arg_valid = rdata.validity;
-			auto tdata = (const INPUT_TYPE *)rdata.data;
+			auto tdata = UnifiedVectorFormat::GetData<INPUT_TYPE>(rdata);
 
 			// Start with a valid flat vector
 			result.SetVectorType(VectorType::FLAT_VECTOR);
@@ -1372,7 +1372,7 @@ struct StructDatePart {
 	static void SerializeFunction(FieldWriter &writer, const FunctionData *bind_data_p,
 	                              const ScalarFunction &function) {
 		D_ASSERT(bind_data_p);
-		auto &info = (BindData &)*bind_data_p;
+		auto &info = bind_data_p->Cast<BindData>();
 		writer.WriteSerializable(info.stype);
 		writer.WriteList<DatePartSpecifier>(info.part_codes);
 	}

package/src/duckdb/src/core_functions/scalar/date/strftime.cpp

@@ -25,7 +25,7 @@ struct StrfTimeBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const StrfTimeBindData &)other_p;
+		auto &other = other_p.Cast<StrfTimeBindData>();
 		return format_string == other.format_string;
 	}
 };
@@ -111,7 +111,7 @@ struct StrpTimeBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const StrpTimeBindData &)other_p;
+		auto &other = other_p.Cast<StrpTimeBindData>();
 		return format_strings == other.format_strings;
 	}
 };

package/src/duckdb/src/core_functions/scalar/generic/current_setting.cpp

@@ -19,7 +19,7 @@ public:
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const CurrentSettingBindData &)other_p;
+		auto &other = other_p.Cast<CurrentSettingBindData>();
 		return Value::NotDistinctFrom(value, other.value);
 	}
 };

package/src/duckdb/src/core_functions/scalar/generic/least.cpp

@@ -37,7 +37,7 @@ static void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vecto
 	{
 		UnifiedVectorFormat vdata;
 		args.data[0].ToUnifiedFormat(args.size(), vdata);
-		auto input_data = (T *)vdata.data;
+		auto input_data = UnifiedVectorFormat::GetData<T>(vdata);
 		for (idx_t i = 0; i < args.size(); i++) {
 			auto vindex = vdata.sel->get_index(i);
 			if (vdata.validity.RowIsValid(vindex)) {
@@ -59,7 +59,7 @@ static void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vecto
 		UnifiedVectorFormat vdata;
 		args.data[col_idx].ToUnifiedFormat(args.size(), vdata);
 
-		auto input_data = (T *)vdata.data;
+		auto input_data = UnifiedVectorFormat::GetData<T>(vdata);
 		if (!vdata.validity.AllValid()) {
 			// potential new null entries: have to check the null mask
 			for (idx_t i = 0; i < args.size(); i++) {

package/src/duckdb/src/core_functions/scalar/generic/stats.cpp

@@ -15,7 +15,7 @@ public:
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const StatsBindData &)other_p;
+		auto &other = other_p.Cast<StatsBindData>();
 		return stats == other.stats;
 	}
 };

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

@@ -107,9 +107,9 @@ static void ExecuteSlice(Vector &result, Vector &s, Vector &b, Vector &e, const
 			auto bidx = bdata.sel->get_index(i);
 			auto eidx = edata.sel->get_index(i);
 
-			auto sliced = ((INPUT_TYPE *)sdata.data)[sidx];
-			auto begin = ((INDEX_TYPE *)bdata.data)[bidx];
-			auto end = ((INDEX_TYPE *)edata.data)[eidx];
+			auto sliced = (UnifiedVectorFormat::GetData<INPUT_TYPE>(sdata))[sidx];
+			auto begin = (UnifiedVectorFormat::GetData<INDEX_TYPE>(bdata))[bidx];
+			auto end = (UnifiedVectorFormat::GetData<INDEX_TYPE>(edata))[eidx];
 
 			auto svalid = sdata.validity.RowIsValid(sidx);
 			auto bvalid = bdata.validity.RowIsValid(bidx);

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

@@ -19,8 +19,7 @@ void ListFlattenFunction(DataChunk &args, ExpressionState &state, Vector &result
 
 	UnifiedVectorFormat list_data;
 	input.ToUnifiedFormat(count, list_data);
-	auto list_entries = (list_entry_t *)list_data.data;
-
+	auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
 	auto &child_vector = ListVector::GetEntry(input);
 
 	result.SetVectorType(VectorType::FLAT_VECTOR);
@@ -28,7 +27,6 @@ void ListFlattenFunction(DataChunk &args, ExpressionState &state, Vector &result
 	auto &result_validity = FlatVector::Validity(result);
 
 	if (child_vector.GetType().id() == LogicalTypeId::SQLNULL) {
-		auto result_entries = FlatVector::GetData<list_entry_t>(result);
 		for (idx_t i = 0; i < count; i++) {
 			auto list_index = list_data.sel->get_index(i);
 			if (!list_data.validity.RowIsValid(list_index)) {
@@ -47,7 +45,7 @@ void ListFlattenFunction(DataChunk &args, ExpressionState &state, Vector &result
 	auto child_size = ListVector::GetListSize(input);
 	UnifiedVectorFormat child_data;
 	child_vector.ToUnifiedFormat(child_size, child_data);
-	auto child_entries = (list_entry_t *)child_data.data;
+	auto child_entries = UnifiedVectorFormat::GetData<list_entry_t>(child_data);
 	auto &data_vector = ListVector::GetEntry(child_vector);
 
 	idx_t offset = 0;

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

@@ -27,8 +27,8 @@ struct ListAggregatesBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const ListAggregatesBindData &)other_p;
-		return stype == other.stype && aggr_expr->Equals(other.aggr_expr.get());
+		auto &other = other_p.Cast<ListAggregatesBindData>();
+		return stype == other.stype && aggr_expr->Equals(*other.aggr_expr);
 	}
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
 		throw NotImplementedException("FIXME: list aggr serialize");
@@ -175,7 +175,7 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 
 	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);
 
 	// state_buffer holds the state for each list of this chunk
 	idx_t size = aggr.function.state_size();

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++) {

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