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

package/src/duckdb/src/core_functions/aggregate/distributive/kurtosis.cpp

@@ -22,7 +22,7 @@ struct KurtosisOperation {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *input,
 	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
 			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
@@ -30,7 +30,7 @@ struct KurtosisOperation {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, const INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
 		state->n++;
 		state->sum += data[idx];
 		state->sum_sqr += pow(data[idx], 2);

package/src/duckdb/src/core_functions/aggregate/distributive/minmax.cpp

@@ -54,8 +54,8 @@ struct MinMaxBase {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &input_data, INPUT_TYPE *input, ValidityMask &mask,
-	                              idx_t count) {
+	static void ConstantOperation(STATE *state, AggregateInputData &input_data, const INPUT_TYPE *input,
+	                              ValidityMask &mask, idx_t count) {
 		D_ASSERT(mask.RowIsValid(0));
 		if (!state->isset) {
 			OP::template Assign<INPUT_TYPE, STATE>(state, input_data, input[0]);
@@ -66,7 +66,7 @@ struct MinMaxBase {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &input_data, INPUT_TYPE *input, ValidityMask &mask,
+	static void Operation(STATE *state, AggregateInputData &input_data, const INPUT_TYPE *input, ValidityMask &mask,
 	                      idx_t idx) {
 		if (!state->isset) {
 			OP::template Assign<INPUT_TYPE, STATE>(state, input_data, input[idx]);
@@ -215,8 +215,8 @@ static bool TemplatedOptimumType(Vector &left, idx_t lidx, idx_t lcount, Vector
 	lidx = lvdata.sel->get_index(lidx);
 	ridx = rvdata.sel->get_index(ridx);
 
-	auto ldata = (const T *)lvdata.data;
-	auto rdata = (const T *)rvdata.data;
+	auto ldata = UnifiedVectorFormat::GetData<T>(lvdata);
+	auto rdata = UnifiedVectorFormat::GetData<T>(rvdata);
 
 	auto &lval = ldata[lidx];
 	auto &rval = rdata[ridx];
@@ -341,8 +341,8 @@ static bool TemplatedOptimumList(Vector &left, idx_t lidx, idx_t lcount, Vector
 	auto &lchild = ListVector::GetEntry(left);
 	auto &rchild = ListVector::GetEntry(right);
 
-	auto ldata = (const list_entry_t *)lvdata.data;
-	auto rdata = (const list_entry_t *)rvdata.data;
+	auto ldata = UnifiedVectorFormat::GetData<list_entry_t>(lvdata);
+	auto rdata = UnifiedVectorFormat::GetData<list_entry_t>(rvdata);
 
 	auto &lval = ldata[lidx];
 	auto &rval = rdata[ridx];

package/src/duckdb/src/core_functions/aggregate/distributive/product.cpp

@@ -33,7 +33,7 @@ struct ProductFunction {
 		target[idx] = state->val;
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, const INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		if (state->empty) {
 			state->empty = false;
 		}
@@ -41,7 +41,7 @@ struct ProductFunction {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *input,
 	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
 			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);

package/src/duckdb/src/core_functions/aggregate/distributive/skew.cpp

@@ -21,7 +21,7 @@ struct SkewnessOperation {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *input,
 	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
 			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
@@ -29,7 +29,7 @@ struct SkewnessOperation {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, const INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
 		state->n++;
 		state->sum += data[idx];
 		state->sum_sqr += pow(data[idx], 2);

package/src/duckdb/src/core_functions/aggregate/distributive/string_agg.cpp

@@ -94,13 +94,13 @@ struct StringAggFunction {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *str_data,
+	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *str_data,
 	                      ValidityMask &str_mask, idx_t str_idx) {
 		PerformOperation(state, str_data[str_idx], aggr_input_data.bind_data);
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *input,
 	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
 			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);

package/src/duckdb/src/core_functions/aggregate/holistic/approximate_quantile.cpp

@@ -38,8 +38,8 @@ struct ApproximateQuantileBindData : public FunctionData {
 
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const AggregateFunction &function) {
 		D_ASSERT(bind_data_p);
-		auto bind_data = (ApproximateQuantileBindData *)bind_data_p;
-		writer.WriteList<float>(bind_data->quantiles);
+		auto &bind_data = bind_data_p->Cast<ApproximateQuantileBindData>();
+		writer.WriteList<float>(bind_data.quantiles);
 	}
 
 	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
@@ -61,7 +61,7 @@ struct ApproxQuantileOperation {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *input,
 	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
 			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
@@ -69,7 +69,7 @@ struct ApproxQuantileOperation {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, const INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
 		auto val = Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(data[idx]);
 		if (!Value::DoubleIsFinite(val)) {
 			return;
@@ -119,9 +119,9 @@ struct ApproxQuantileScalarOperation : public ApproxQuantileOperation {
 		D_ASSERT(state->h);
 		D_ASSERT(aggr_input_data.bind_data);
 		state->h->compress();
-		auto bind_data = (ApproximateQuantileBindData *)aggr_input_data.bind_data;
-		D_ASSERT(bind_data->quantiles.size() == 1);
-		target[idx] = Cast::template Operation<SAVE_TYPE, TARGET_TYPE>(state->h->quantile(bind_data->quantiles[0]));
+		auto &bind_data = aggr_input_data.bind_data->template Cast<ApproximateQuantileBindData>();
+		D_ASSERT(bind_data.quantiles.size() == 1);
+		target[idx] = Cast::template Operation<SAVE_TYPE, TARGET_TYPE>(state->h->quantile(bind_data.quantiles[0]));
 	}
 };
 
@@ -220,11 +220,11 @@ struct ApproxQuantileListOperation : public ApproxQuantileOperation {
 		}
 
 		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (ApproximateQuantileBindData *)aggr_input_data.bind_data;
+		auto &bind_data = aggr_input_data.bind_data->template Cast<ApproximateQuantileBindData>();
 
 		auto &result = ListVector::GetEntry(result_list);
 		auto ridx = ListVector::GetListSize(result_list);
-		ListVector::Reserve(result_list, ridx + bind_data->quantiles.size());
+		ListVector::Reserve(result_list, ridx + bind_data.quantiles.size());
 		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
 
 		D_ASSERT(state->h);
@@ -232,9 +232,9 @@ struct ApproxQuantileListOperation : public ApproxQuantileOperation {
 
 		auto &entry = target[idx];
 		entry.offset = ridx;
-		entry.length = bind_data->quantiles.size();
+		entry.length = bind_data.quantiles.size();
 		for (size_t q = 0; q < entry.length; ++q) {
-			const auto &quantile = bind_data->quantiles[q];
+			const auto &quantile = bind_data.quantiles[q];
 			rdata[ridx + q] = Cast::template Operation<SAVE_TYPE, CHILD_TYPE>(state->h->quantile(quantile));
 		}
 
@@ -247,11 +247,11 @@ struct ApproxQuantileListOperation : public ApproxQuantileOperation {
 		D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
 
 		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (ApproximateQuantileBindData *)aggr_input_data.bind_data;
+		auto &bind_data = aggr_input_data.bind_data->template Cast<ApproximateQuantileBindData>();
 
 		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ListVector::Reserve(result, bind_data->quantiles.size());
+			ListVector::Reserve(result, bind_data.quantiles.size());
 
 			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
 			auto rdata = ConstantVector::GetData<RESULT_TYPE>(result);
@@ -260,7 +260,7 @@ struct ApproxQuantileListOperation : public ApproxQuantileOperation {
 		} else {
 			D_ASSERT(states.GetVectorType() == VectorType::FLAT_VECTOR);
 			result.SetVectorType(VectorType::FLAT_VECTOR);
-			ListVector::Reserve(result, (offset + count) * bind_data->quantiles.size());
+			ListVector::Reserve(result, (offset + count) * bind_data.quantiles.size());
 
 			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
 			auto rdata = FlatVector::GetData<RESULT_TYPE>(result);

package/src/duckdb/src/core_functions/aggregate/holistic/mode.cpp

@@ -155,7 +155,7 @@ struct ModeFunction {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, const INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
 		if (!state->frequency_map) {
 			state->frequency_map = new typename STATE::Counts();
 		}
@@ -199,7 +199,7 @@ struct ModeFunction {
 		}
 	}
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &, INPUT_TYPE *input, ValidityMask &mask,
+	static void ConstantOperation(STATE *state, AggregateInputData &, const INPUT_TYPE *input, ValidityMask &mask,
 	                              idx_t count) {
 		if (!state->frequency_map) {
 			state->frequency_map = new typename STATE::Counts();

package/src/duckdb/src/core_functions/aggregate/holistic/quantile.cpp

@@ -464,7 +464,7 @@ struct QuantileOperation {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
+	static void Operation(STATE *state, AggregateInputData &, const INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
 		state->v.emplace_back(data[idx]);
 	}
 
@@ -493,11 +493,11 @@ static void ExecuteListFinalize(Vector &states, AggregateInputData &aggr_input_d
 	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
 
 	D_ASSERT(aggr_input_data.bind_data);
-	auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
+	auto &bind_data = aggr_input_data.bind_data->Cast<QuantileBindData>();
 
 	if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-		ListVector::Reserve(result, bind_data->quantiles.size());
+		ListVector::Reserve(result, bind_data.quantiles.size());
 
 		auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
 		auto rdata = ConstantVector::GetData<RESULT_TYPE>(result);
@@ -506,7 +506,7 @@ static void ExecuteListFinalize(Vector &states, AggregateInputData &aggr_input_d
 	} else {
 		D_ASSERT(states.GetVectorType() == VectorType::FLAT_VECTOR);
 		result.SetVectorType(VectorType::FLAT_VECTOR);
-		ListVector::Reserve(result, (offset + count) * bind_data->quantiles.size());
+		ListVector::Reserve(result, (offset + count) * bind_data.quantiles.size());
 
 		auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
 		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
@@ -540,9 +540,9 @@ struct QuantileScalarOperation : public QuantileOperation {
 			return;
 		}
 		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
-		D_ASSERT(bind_data->quantiles.size() == 1);
-		Interpolator<DISCRETE> interp(bind_data->quantiles[0], state->v.size(), bind_data->desc);
+		auto &bind_data = aggr_input_data.bind_data->Cast<QuantileBindData>();
+		D_ASSERT(bind_data.quantiles.size() == 1);
+		Interpolator<DISCRETE> interp(bind_data.quantiles[0], state->v.size(), bind_data.desc);
 		target[idx] = interp.template Operation<typename STATE::SaveType, RESULT_TYPE>(state->v.data(), result);
 	}
 
@@ -563,10 +563,10 @@ struct QuantileScalarOperation : public QuantileOperation {
 		D_ASSERT(index);
 
 		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
+		auto &bind_data = aggr_input_data.bind_data->Cast<QuantileBindData>();
 
 		// Find the two positions needed
-		const auto q = bind_data->quantiles[0];
+		const auto q = bind_data.quantiles[0];
 
 		bool replace = false;
 		if (frame.first == prev.first + 1 && frame.second == prev.second + 1) {
@@ -670,11 +670,11 @@ struct QuantileListOperation : public QuantileOperation {
 		}
 
 		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
+		auto &bind_data = aggr_input_data.bind_data->Cast<QuantileBindData>();
 
 		auto &result = ListVector::GetEntry(result_list);
 		auto ridx = ListVector::GetListSize(result_list);
-		ListVector::Reserve(result_list, ridx + bind_data->quantiles.size());
+		ListVector::Reserve(result_list, ridx + bind_data.quantiles.size());
 		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
 
 		auto v_t = state->v.data();
@@ -683,14 +683,14 @@ struct QuantileListOperation : public QuantileOperation {
 		auto &entry = target[idx];
 		entry.offset = ridx;
 		idx_t lower = 0;
-		for (const auto &q : bind_data->order) {
-			const auto &quantile = bind_data->quantiles[q];
-			Interpolator<DISCRETE> interp(quantile, state->v.size(), bind_data->desc);
+		for (const auto &q : bind_data.order) {
+			const auto &quantile = bind_data.quantiles[q];
+			Interpolator<DISCRETE> interp(quantile, state->v.size(), bind_data.desc);
 			interp.begin = lower;
 			rdata[ridx + q] = interp.template Operation<typename STATE::SaveType, CHILD_TYPE>(v_t, result);
 			lower = interp.FRN;
 		}
-		entry.length = bind_data->quantiles.size();
+		entry.length = bind_data.quantiles.size();
 
 		ListVector::SetListSize(result_list, entry.offset + entry.length);
 	}
@@ -700,7 +700,7 @@ struct QuantileListOperation : public QuantileOperation {
 	                   AggregateInputData &aggr_input_data, STATE *state, const FrameBounds &frame,
 	                   const FrameBounds &prev, Vector &list, idx_t lidx, idx_t bias) {
 		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (QuantileBindData *)aggr_input_data.bind_data;
+		auto &bind_data = aggr_input_data.bind_data->Cast<QuantileBindData>();
 
 		QuantileIncluded included(fmask, dmask, bias);
 
@@ -709,7 +709,7 @@ struct QuantileListOperation : public QuantileOperation {
 		auto &lmask = FlatVector::Validity(list);
 		auto &lentry = ldata[lidx];
 		lentry.offset = ListVector::GetListSize(list);
-		lentry.length = bind_data->quantiles.size();
+		lentry.length = bind_data.quantiles.size();
 
 		ListVector::Reserve(list, lentry.offset + lentry.length);
 		ListVector::SetListSize(list, lentry.offset + lentry.length);
@@ -734,8 +734,8 @@ struct QuantileListOperation : public QuantileOperation {
 			const auto j = ReplaceIndex(index, frame, prev);
 			//	We can only replace if the number of NULLs has not changed
 			if (included.AllValid() || included(prev.first) == included(prev.second)) {
-				for (const auto &q : bind_data->order) {
-					const auto &quantile = bind_data->quantiles[q];
+				for (const auto &q : bind_data.order) {
+					const auto &quantile = bind_data.quantiles[q];
 					Interpolator<DISCRETE> interp(quantile, prev_pos, false);
 					const auto replace = CanReplace(index, data, j, interp.FRN, interp.CRN, included);
 					if (replace < 0) {
@@ -765,8 +765,8 @@ struct QuantileListOperation : public QuantileOperation {
 		if (state->pos) {
 			using ID = QuantileIndirect<INPUT_TYPE>;
 			ID indirect(data);
-			for (const auto &q : bind_data->order) {
-				const auto &quantile = bind_data->quantiles[q];
+			for (const auto &q : bind_data.order) {
+				const auto &quantile = bind_data.quantiles[q];
 				Interpolator<DISCRETE> interp(quantile, state->pos, false);
 				if (replaceable.first <= interp.FRN && interp.CRN <= replaceable.second) {
 					rdata[lentry.offset + q] = interp.template Replace<idx_t, CHILD_TYPE, ID>(index, result, indirect);

package/src/duckdb/src/core_functions/aggregate/holistic/reservoir_quantile.cpp

@@ -66,9 +66,9 @@ struct ReservoirQuantileBindData : public FunctionData {
 
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const AggregateFunction &function) {
 		D_ASSERT(bind_data_p);
-		auto bind_data = (ReservoirQuantileBindData *)bind_data_p;
-		writer.WriteList<double>(bind_data->quantiles);
-		writer.WriteField<int32_t>(bind_data->sample_size);
+		auto &bind_data = bind_data_p->Cast<ReservoirQuantileBindData>();
+		writer.WriteList<double>(bind_data.quantiles);
+		writer.WriteField<int32_t>(bind_data.sample_size);
 	}
 
 	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
@@ -92,7 +92,7 @@ struct ReservoirQuantileOperation {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *input,
+	static void ConstantOperation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *input,
 	                              ValidityMask &mask, idx_t count) {
 		for (idx_t i = 0; i < count; i++) {
 			Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
@@ -100,18 +100,17 @@ struct ReservoirQuantileOperation {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &aggr_input_data, INPUT_TYPE *data, ValidityMask &mask,
+	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const INPUT_TYPE *data, ValidityMask &mask,
 	                      idx_t idx) {
-		auto bind_data = (ReservoirQuantileBindData *)aggr_input_data.bind_data;
-		D_ASSERT(bind_data);
+		auto &bind_data = aggr_input_data.bind_data->template Cast<ReservoirQuantileBindData>();
 		if (state->pos == 0) {
-			state->Resize(bind_data->sample_size);
+			state->Resize(bind_data.sample_size);
 		}
 		if (!state->r_samp) {
 			state->r_samp = new BaseReservoirSampling();
 		}
 		D_ASSERT(state->v);
-		state->FillReservoir(bind_data->sample_size, data[idx]);
+		state->FillReservoir(bind_data.sample_size, data[idx]);
 	}
 
 	template <class STATE, class OP>
@@ -157,10 +156,10 @@ struct ReservoirQuantileScalarOperation : public ReservoirQuantileOperation {
 		}
 		D_ASSERT(state->v);
 		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (ReservoirQuantileBindData *)aggr_input_data.bind_data;
+		auto &bind_data = aggr_input_data.bind_data->template Cast<ReservoirQuantileBindData>();
 		auto v_t = state->v;
-		D_ASSERT(bind_data->quantiles.size() == 1);
-		auto offset = (idx_t)((double)(state->pos - 1) * bind_data->quantiles[0]);
+		D_ASSERT(bind_data.quantiles.size() == 1);
+		auto offset = (idx_t)((double)(state->pos - 1) * bind_data.quantiles[0]);
 		std::nth_element(v_t, v_t + offset, v_t + state->pos);
 		target[idx] = v_t[offset];
 	}
@@ -217,11 +216,11 @@ struct ReservoirQuantileListOperation : public ReservoirQuantileOperation {
 		}
 
 		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (ReservoirQuantileBindData *)aggr_input_data.bind_data;
+		auto &bind_data = aggr_input_data.bind_data->template Cast<ReservoirQuantileBindData>();
 
 		auto &result = ListVector::GetEntry(result_list);
 		auto ridx = ListVector::GetListSize(result_list);
-		ListVector::Reserve(result_list, ridx + bind_data->quantiles.size());
+		ListVector::Reserve(result_list, ridx + bind_data.quantiles.size());
 		auto rdata = FlatVector::GetData<CHILD_TYPE>(result);
 
 		auto v_t = state->v;
@@ -229,9 +228,9 @@ struct ReservoirQuantileListOperation : public ReservoirQuantileOperation {
 
 		auto &entry = target[idx];
 		entry.offset = ridx;
-		entry.length = bind_data->quantiles.size();
+		entry.length = bind_data.quantiles.size();
 		for (size_t q = 0; q < entry.length; ++q) {
-			const auto &quantile = bind_data->quantiles[q];
+			const auto &quantile = bind_data.quantiles[q];
 			auto offset = (idx_t)((double)(state->pos - 1) * quantile);
 			std::nth_element(v_t, v_t + offset, v_t + state->pos);
 			rdata[ridx + q] = v_t[offset];
@@ -246,11 +245,11 @@ struct ReservoirQuantileListOperation : public ReservoirQuantileOperation {
 		D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
 
 		D_ASSERT(aggr_input_data.bind_data);
-		auto bind_data = (ReservoirQuantileBindData *)aggr_input_data.bind_data;
+		auto &bind_data = aggr_input_data.bind_data->Cast<ReservoirQuantileBindData>();
 
 		if (states.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			ListVector::Reserve(result, bind_data->quantiles.size());
+			ListVector::Reserve(result, bind_data.quantiles.size());
 
 			auto sdata = ConstantVector::GetData<STATE_TYPE *>(states);
 			auto rdata = ConstantVector::GetData<RESULT_TYPE>(result);
@@ -259,7 +258,7 @@ struct ReservoirQuantileListOperation : public ReservoirQuantileOperation {
 		} else {
 			D_ASSERT(states.GetVectorType() == VectorType::FLAT_VECTOR);
 			result.SetVectorType(VectorType::FLAT_VECTOR);
-			ListVector::Reserve(result, (offset + count) * bind_data->quantiles.size());
+			ListVector::Reserve(result, (offset + count) * bind_data.quantiles.size());
 
 			auto sdata = FlatVector::GetData<STATE_TYPE *>(states);
 			auto rdata = FlatVector::GetData<RESULT_TYPE>(result);

package/src/duckdb/src/core_functions/aggregate/nested/histogram.cpp

@@ -18,7 +18,7 @@ struct HistogramFunctor {
 				if (!state->hist) {
 					state->hist = new MAP_TYPE();
 				}
-				auto value = (T *)input_data.data;
+				auto value = UnifiedVectorFormat::GetData<T>(input_data);
 				(*state->hist)[value[input_data.sel->get_index(i)]]++;
 			}
 		}
@@ -33,16 +33,15 @@ struct HistogramFunctor {
 struct HistogramStringFunctor {
 	template <class T, class MAP_TYPE = map<T, idx_t>>
 	static void HistogramUpdate(UnifiedVectorFormat &sdata, UnifiedVectorFormat &input_data, idx_t count) {
-
 		auto states = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
+		auto input_strings = UnifiedVectorFormat::GetData<string_t>(input_data);
 		for (idx_t i = 0; i < count; i++) {
 			if (input_data.validity.RowIsValid(input_data.sel->get_index(i))) {
 				auto state = states[sdata.sel->get_index(i)];
 				if (!state->hist) {
 					state->hist = new MAP_TYPE();
 				}
-				auto value = (string_t *)input_data.data;
-				(*state->hist)[value[input_data.sel->get_index(i)].GetString()]++;
+				(*state->hist)[input_strings[input_data.sel->get_index(i)].GetString()]++;
 			}
 		}
 	}

package/src/duckdb/src/core_functions/aggregate/nested/list.cpp

@@ -35,7 +35,7 @@ struct ListBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const ListBindData &)other_p;
+		auto &other = other_p.Cast<ListBindData>();
 		return stype == other.stype;
 	}
 };
@@ -80,7 +80,7 @@ static void ListUpdateFunction(Vector inputs[], AggregateInputData &aggr_input_d
 	UnifiedVectorFormat sdata;
 	state_vector.ToUnifiedFormat(count, sdata);
 
-	auto states = (ListAggState **)sdata.data;
+	auto states = UnifiedVectorFormat::GetData<ListAggState *>(sdata);
 	RecursiveFlatten(input, count);
 
 	auto &list_bind_data = aggr_input_data.bind_data->Cast<ListBindData>();
@@ -94,7 +94,7 @@ static void ListUpdateFunction(Vector inputs[], AggregateInputData &aggr_input_d
 static void ListCombineFunction(Vector &state, Vector &combined, AggregateInputData &aggr_input_data, idx_t count) {
 	UnifiedVectorFormat sdata;
 	state.ToUnifiedFormat(count, sdata);
-	auto states_ptr = (ListAggState **)sdata.data;
+	auto states_ptr = UnifiedVectorFormat::GetData<ListAggState *>(sdata);
 
 	auto &list_bind_data = aggr_input_data.bind_data->Cast<ListBindData>();
 
@@ -125,7 +125,7 @@ static void ListFinalize(Vector &state_vector, AggregateInputData &aggr_input_da
                          idx_t offset) {
 	UnifiedVectorFormat sdata;
 	state_vector.ToUnifiedFormat(count, sdata);
-	auto states = (ListAggState **)sdata.data;
+	auto states = UnifiedVectorFormat::GetData<ListAggState *>(sdata);
 
 	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
 

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

@@ -37,8 +37,8 @@ struct RegrAvgFunction {
 };
 struct RegrAvgXFunction : RegrAvgFunction {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
-	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
+	static void Operation(STATE *state, AggregateInputData &, const A_TYPE *x_data, const B_TYPE *y_data,
+	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
 		state->sum += y_data[yidx];
 		state->count++;
 	}
@@ -46,8 +46,8 @@ struct RegrAvgXFunction : RegrAvgFunction {
 
 struct RegrAvgYFunction : RegrAvgFunction {
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
-	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
+	static void Operation(STATE *state, AggregateInputData &, const A_TYPE *x_data, const B_TYPE *y_data,
+	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
 		state->sum += x_data[xidx];
 		state->count++;
 	}

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

@@ -23,7 +23,7 @@ struct RegrInterceptOperation {
 	}
 
 	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,
+	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const A_TYPE *x_data, const B_TYPE *y_data,
 	                      ValidityMask &amask, ValidityMask &bmask, idx_t xidx, idx_t yidx) {
 		state->count++;
 		state->sum_x += y_data[yidx];

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

@@ -24,7 +24,7 @@ struct RegrR2Operation {
 	}
 
 	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,
+	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const A_TYPE *x_data, const 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);

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

@@ -49,7 +49,7 @@ 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,
+	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const A_TYPE *x_data, const 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);
@@ -59,7 +59,7 @@ struct RegrSXXOperation : RegrBaseOperation {
 
 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,
+	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const A_TYPE *x_data, const 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);

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

@@ -20,7 +20,7 @@ struct RegrSXYOperation {
 	}
 
 	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,
+	static void Operation(STATE *state, AggregateInputData &aggr_input_data, const A_TYPE *x_data, const 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);

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