duckdb 0.8.1-dev23.0 → 0.8.1-dev253.0

package/src/duckdb/src/core_functions/aggregate/regression/regr_r2.cpp

@@ -17,51 +17,46 @@ struct RegrR2State {
 
 struct RegrR2Operation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		CorrOperation::Initialize<CorrState>(&state->corr);
-		STDDevBaseOperation::Initialize<StddevState>(&state->var_pop_x);
-		STDDevBaseOperation::Initialize<StddevState>(&state->var_pop_y);
+	static void Initialize(STATE &state) {
+		CorrOperation::Initialize<CorrState>(state.corr);
+		STDDevBaseOperation::Initialize<StddevState>(state.var_pop_x);
+		STDDevBaseOperation::Initialize<StddevState>(state.var_pop_y);
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, A_TYPE *x_data, B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		CorrOperation::Operation<A_TYPE, B_TYPE, CorrState, OP>(&state->corr, aggr_input_data, y_data, x_data, bmask,
-		                                                        amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop_x, aggr_input_data, y_data, bmask,
-		                                                        yidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop_y, aggr_input_data, x_data, amask,
-		                                                        xidx);
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		CorrOperation::Operation<A_TYPE, B_TYPE, CorrState, OP>(state.corr, x, y, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop_x, y);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop_y, x);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		CorrOperation::Combine<CorrState, OP>(source.corr, &target->corr, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_x, &target->var_pop_x, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_y, &target->var_pop_y, aggr_input_data);
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
+		CorrOperation::Combine<CorrState, OP>(source.corr, target.corr, aggr_input_data);
+		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_x, target.var_pop_x, aggr_input_data);
+		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop_y, target.var_pop_y, aggr_input_data);
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		auto var_pop_x = state->var_pop_x.count > 1 ? (state->var_pop_x.dsquared / state->var_pop_x.count) : 0;
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		auto var_pop_x = state.var_pop_x.count > 1 ? (state.var_pop_x.dsquared / state.var_pop_x.count) : 0;
 		if (!Value::DoubleIsFinite(var_pop_x)) {
 			throw OutOfRangeException("VARPOP(X) is out of range!");
 		}
 		if (var_pop_x == 0) {
-			mask.SetInvalid(idx);
+			finalize_data.ReturnNull();
 			return;
 		}
-		auto var_pop_y = state->var_pop_y.count > 1 ? (state->var_pop_y.dsquared / state->var_pop_y.count) : 0;
+		auto var_pop_y = state.var_pop_y.count > 1 ? (state.var_pop_y.dsquared / state.var_pop_y.count) : 0;
 		if (!Value::DoubleIsFinite(var_pop_y)) {
 			throw OutOfRangeException("VARPOP(Y) is out of range!");
 		}
 		if (var_pop_y == 0) {
-			target[idx] = 1;
+			target = 1;
 			return;
 		}
-		CorrOperation::Finalize<T, CorrState>(result, aggr_input_data, &state->corr, target, mask, idx);
-		target[idx] = pow(target[idx], 2);
+		CorrOperation::Finalize<T, CorrState>(state.corr, target, finalize_data);
+		target = pow(target, 2);
 	}
 
 	static bool IgnoreNull() {

package/src/duckdb/src/core_functions/aggregate/regression/regr_sxx_syy.cpp

@@ -16,30 +16,29 @@ struct RegrSState {
 
 struct RegrBaseOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		RegrCountFunction::Initialize<size_t>(&state->count);
-		STDDevBaseOperation::Initialize<StddevState>(&state->var_pop);
+	static void Initialize(STATE &state) {
+		RegrCountFunction::Initialize<size_t>(state.count);
+		STDDevBaseOperation::Initialize<StddevState>(state.var_pop);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		RegrCountFunction::Combine<size_t, OP>(source.count, &target->count, aggr_input_data);
-		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, &target->var_pop, aggr_input_data);
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
+		RegrCountFunction::Combine<size_t, OP>(source.count, target.count, aggr_input_data);
+		STDDevBaseOperation::Combine<StddevState, OP>(source.var_pop, target.var_pop, aggr_input_data);
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		if (state->var_pop.count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.var_pop.count == 0) {
+			finalize_data.ReturnNull();
 			return;
 		}
-		auto var_pop = state->var_pop.count > 1 ? (state->var_pop.dsquared / state->var_pop.count) : 0;
+		auto var_pop = state.var_pop.count > 1 ? (state.var_pop.dsquared / state.var_pop.count) : 0;
 		if (!Value::DoubleIsFinite(var_pop)) {
 			throw OutOfRangeException("VARPOP is out of range!");
 		}
-		RegrCountFunction::Finalize<T, size_t>(result, aggr_input_data, &state->count, target, mask, idx);
-		target[idx] *= var_pop;
+		RegrCountFunction::Finalize<T, size_t>(state.count, target, finalize_data);
+		target *= var_pop;
 	}
 
 	static bool IgnoreNull() {
@@ -49,21 +48,17 @@ struct RegrBaseOperation {
 
 struct RegrSXXOperation : RegrBaseOperation {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, A_TYPE *x_data, B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(&state->count, aggr_input_data, y_data, x_data, bmask,
-		                                                         amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, aggr_input_data, y_data, bmask, yidx);
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, x, y, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, y);
 	}
 };
 
 struct RegrSYYOperation : RegrBaseOperation {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, A_TYPE *x_data, B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(&state->count, aggr_input_data, y_data, x_data, bmask,
-		                                                         amask, yidx, xidx);
-		STDDevBaseOperation::Operation<A_TYPE, StddevState, OP>(&state->var_pop, aggr_input_data, x_data, bmask, xidx);
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, x, y, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, x);
 	}
 };
 

package/src/duckdb/src/core_functions/aggregate/regression/regr_sxy.cpp

@@ -14,33 +14,29 @@ struct RegrSXyState {
 
 struct RegrSXYOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		RegrCountFunction::Initialize<size_t>(&state->count);
-		CovarOperation::Initialize<CovarState>(&state->cov_pop);
+	static void Initialize(STATE &state) {
+		RegrCountFunction::Initialize<size_t>(state.count);
+		CovarOperation::Initialize<CovarState>(state.cov_pop);
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, A_TYPE *x_data, B_TYPE *y_data,
-	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
-		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(&state->count, aggr_input_data, y_data, x_data, bmask,
-		                                                         amask, yidx, xidx);
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(&state->cov_pop, aggr_input_data, x_data, y_data,
-		                                                          amask, bmask, xidx, yidx);
+	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+		RegrCountFunction::Operation<A_TYPE, B_TYPE, size_t, OP>(state.count, x, y, idata);
+		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, x, y, idata);
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		CovarOperation::Combine<CovarState, OP>(source.cov_pop, &target->cov_pop, aggr_input_data);
-		RegrCountFunction::Combine<size_t, OP>(source.count, &target->count, aggr_input_data);
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
+		CovarOperation::Combine<CovarState, OP>(source.cov_pop, target.cov_pop, aggr_input_data);
+		RegrCountFunction::Combine<size_t, OP>(source.count, target.count, aggr_input_data);
 	}
 
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &aggr_input_data, STATE *state, T *target,
-	                     ValidityMask &mask, idx_t idx) {
-		CovarPopOperation::Finalize<T, CovarState>(result, aggr_input_data, &state->cov_pop, target, mask, idx);
-		auto cov_pop = target[idx];
-		RegrCountFunction::Finalize<T, size_t>(result, aggr_input_data, &state->count, target, mask, idx);
-		target[idx] *= cov_pop;
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		CovarPopOperation::Finalize<T, CovarState>(state.cov_pop, target, finalize_data);
+		auto cov_pop = target;
+		RegrCountFunction::Finalize<T, size_t>(state.count, target, finalize_data);
+		target *= cov_pop;
 	}
 
 	static bool IgnoreNull() {

package/src/duckdb/src/core_functions/function_list.cpp

@@ -169,6 +169,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION_SET(HexFun),
 	DUCKDB_AGGREGATE_FUNCTION_SET(HistogramFun),
 	DUCKDB_SCALAR_FUNCTION_SET(HoursFun),
+	DUCKDB_SCALAR_FUNCTION(InSearchPathFun),
 	DUCKDB_SCALAR_FUNCTION(InstrFun),
 	DUCKDB_SCALAR_FUNCTION_SET(IsFiniteFun),
 	DUCKDB_SCALAR_FUNCTION_SET(IsInfiniteFun),

package/src/duckdb/src/core_functions/scalar/blob/base64.cpp

@@ -18,7 +18,7 @@ struct Base64DecodeOperator {
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
 		auto result_size = Blob::FromBase64Size(input);
 		auto result_blob = StringVector::EmptyString(result, result_size);
-		Blob::FromBase64(input, (data_ptr_t)result_blob.GetDataWriteable(), result_size);
+		Blob::FromBase64(input, data_ptr_cast(result_blob.GetDataWriteable()), result_size);
 		result_blob.Finalize();
 		return result_blob;
 	}

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/generic/system_functions.cpp

@@ -49,6 +49,16 @@ static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vec
 	result.Reference(val);
 }
 
+// in_search_path
+static void InSearchPathFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	auto &context = state.GetContext();
+	auto &search_path = ClientData::Get(context).catalog_search_path;
+	BinaryExecutor::Execute<string_t, string_t, bool>(
+	    input.data[0], input.data[1], result, input.size(), [&](string_t db_name, string_t schema_name) {
+		    return search_path->SchemaInSearchPath(context, db_name.GetString(), schema_name.GetString());
+	    });
+}
+
 // txid_current
 static void TransactionIdCurrent(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &context = state.GetContext();
@@ -83,6 +93,10 @@ ScalarFunction CurrentSchemasFun::GetFunction() {
 	return ScalarFunction({LogicalType::BOOLEAN}, varchar_list_type, CurrentSchemasFunction);
 }
 
+ScalarFunction InSearchPathFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN, InSearchPathFunction);
+}
+
 ScalarFunction CurrentTransactionIdFun::GetFunction() {
 	return ScalarFunction({}, LogicalType::BIGINT, TransactionIdCurrent);
 }

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