duckdb 0.8.1-dev65.0 → 0.8.1

package/src/duckdb/src/common/types.cpp

@@ -559,6 +559,10 @@ bool LogicalType::GetDecimalProperties(uint8_t &width, uint8_t &scale) const {
 		scale = DecimalType::GetScale(*this);
 		break;
 	default:
+		// Nonsense values to ensure initialization
+		width = 255u;
+		scale = 255u;
+		// FIXME(carlo): This should be probably a throw, requires checkign the various call-sites
 		return false;
 	}
 	return true;
@@ -811,6 +815,17 @@ public:
 	virtual void FormatSerialize(FormatSerializer &serializer) const;
 	static shared_ptr<ExtraTypeInfo> FormatDeserialize(FormatDeserializer &source);
 
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+
 protected:
 	virtual bool EqualsInternal(ExtraTypeInfo *other_p) const {
 		// Do nothing
@@ -888,7 +903,7 @@ public:
 
 protected:
 	bool EqualsInternal(ExtraTypeInfo *other_p) const override {
-		auto &other = (DecimalTypeInfo &)*other_p;
+		auto &other = other_p->Cast<DecimalTypeInfo>();
 		return width == other.width && scale == other.scale;
 	}
 };
@@ -897,14 +912,14 @@ uint8_t DecimalType::GetWidth(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
-	return ((DecimalTypeInfo &)*info).width;
+	return info->Cast<DecimalTypeInfo>().width;
 }
 
 uint8_t DecimalType::GetScale(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
-	return ((DecimalTypeInfo &)*info).scale;
+	return info->Cast<DecimalTypeInfo>().scale;
 }
 
 uint8_t DecimalType::MaxWidth() {
@@ -965,7 +980,7 @@ string StringType::GetCollation(const LogicalType &type) {
 	if (info->type == ExtraTypeInfoType::GENERIC_TYPE_INFO) {
 		return string();
 	}
-	return ((StringTypeInfo &)*info).collation;
+	return info->Cast<StringTypeInfo>().collation;
 }
 
 LogicalType LogicalType::VARCHAR_COLLATION(string collation) { // NOLINT
@@ -1005,7 +1020,7 @@ public:
 
 protected:
 	bool EqualsInternal(ExtraTypeInfo *other_p) const override {
-		auto &other = (ListTypeInfo &)*other_p;
+		auto &other = other_p->Cast<ListTypeInfo>();
 		return child_type == other.child_type;
 	}
 };
@@ -1014,7 +1029,7 @@ const LogicalType &ListType::GetChildType(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::LIST || type.id() == LogicalTypeId::MAP);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
-	return ((ListTypeInfo &)*info).child_type;
+	return info->Cast<ListTypeInfo>().child_type;
 }
 
 LogicalType LogicalType::LIST(const LogicalType &child) {
@@ -1066,7 +1081,7 @@ public:
 
 protected:
 	bool EqualsInternal(ExtraTypeInfo *other_p) const override {
-		auto &other = (StructTypeInfo &)*other_p;
+		auto &other = other_p->Cast<StructTypeInfo>();
 		return child_types == other.child_types;
 	}
 };
@@ -1122,7 +1137,7 @@ public:
 
 protected:
 	bool EqualsInternal(ExtraTypeInfo *other_p) const override {
-		auto &other = (AggregateStateTypeInfo &)*other_p;
+		auto &other = other_p->Cast<AggregateStateTypeInfo>();
 		return state_type.function_name == other.state_type.function_name &&
 		       state_type.return_type == other.state_type.return_type &&
 		       state_type.bound_argument_types == other.state_type.bound_argument_types;
@@ -1133,7 +1148,7 @@ const aggregate_state_t &AggregateStateType::GetStateType(const LogicalType &typ
 	D_ASSERT(type.id() == LogicalTypeId::AGGREGATE_STATE);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
-	return ((AggregateStateTypeInfo &)*info).state_type;
+	return info->Cast<AggregateStateTypeInfo>().state_type;
 }
 
 const string AggregateStateType::GetTypeName(const LogicalType &type) {
@@ -1142,7 +1157,7 @@ const string AggregateStateType::GetTypeName(const LogicalType &type) {
 	if (!info) {
 		return "AGGREGATE_STATE<?>";
 	}
-	auto aggr_state = ((AggregateStateTypeInfo &)*info).state_type;
+	auto aggr_state = info->Cast<AggregateStateTypeInfo>().state_type;
 	return "AGGREGATE_STATE<" + aggr_state.function_name + "(" +
 	       StringUtil::Join(aggr_state.bound_argument_types, aggr_state.bound_argument_types.size(), ", ",
 	                        [](const LogicalType &arg_type) { return arg_type.ToString(); }) +
@@ -1154,7 +1169,7 @@ const child_list_t<LogicalType> &StructType::GetChildTypes(const LogicalType &ty
 
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
-	return ((StructTypeInfo &)*info).child_types;
+	return info->Cast<StructTypeInfo>().child_types;
 }
 
 const LogicalType &StructType::GetChildType(const LogicalType &type, idx_t index) {
@@ -1277,7 +1292,7 @@ public:
 
 protected:
 	bool EqualsInternal(ExtraTypeInfo *other_p) const override {
-		auto &other = (UserTypeInfo &)*other_p;
+		auto &other = other_p->Cast<UserTypeInfo>();
 		return other.user_type_name == user_type_name;
 	}
 };
@@ -1286,7 +1301,7 @@ const string &UserType::GetTypeName(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::USER);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
-	return ((UserTypeInfo &)*info).user_type_name;
+	return info->Cast<UserTypeInfo>().user_type_name;
 }
 
 LogicalType LogicalType::USER(const string &user_type_name) {
@@ -1306,19 +1321,19 @@ struct EnumTypeInfo : public ExtraTypeInfo {
 	      dict_type(EnumDictType::VECTOR_DICT), enum_name(std::move(enum_name_p)), dict_size(dict_size_p) {
 	}
 
-	const EnumDictType &GetEnumDictType() {
+	const EnumDictType &GetEnumDictType() const {
 		return dict_type;
 	};
-	const string &GetEnumName() {
+	const string &GetEnumName() const {
 		return enum_name;
 	};
 	const string GetSchemaName() const {
 		return catalog_entry ? catalog_entry->schema.name : "";
 	};
-	const Vector &GetValuesInsertOrder() {
+	const Vector &GetValuesInsertOrder() const {
 		return values_insert_order;
 	};
-	const idx_t &GetDictSize() {
+	const idx_t &GetDictSize() const {
 		return dict_size;
 	};
 	EnumTypeInfo(const EnumTypeInfo &) = delete;
@@ -1327,7 +1342,7 @@ struct EnumTypeInfo : public ExtraTypeInfo {
 protected:
 	// Equalities are only used in enums with different catalog entries
 	bool EqualsInternal(ExtraTypeInfo *other_p) const override {
-		auto &other = (EnumTypeInfo &)*other_p;
+		auto &other = other_p->Cast<EnumTypeInfo>();
 		if (dict_type != other.dict_type) {
 			return false;
 		}
@@ -1360,7 +1375,7 @@ protected:
 		ExtraTypeInfo::FormatSerialize(serializer);
 		serializer.WriteProperty("dict_size", dict_size);
 		serializer.WriteProperty("enum_name", enum_name);
-		((Vector &)values_insert_order).FormatSerialize(serializer, dict_size);
+		((Vector &)values_insert_order).FormatSerialize(serializer, dict_size); // NOLINT - FIXME
 	}
 	Vector values_insert_order;
 
@@ -1374,7 +1389,7 @@ private:
 
 void EnumType::Serialize(FieldWriter &writer, const ExtraTypeInfo &type_info, bool serialize_internals) {
 	D_ASSERT(type_info.type == ExtraTypeInfoType::ENUM_TYPE_INFO);
-	auto &enum_info = (EnumTypeInfo &)type_info;
+	auto &enum_info = type_info.Cast<EnumTypeInfo>();
 	// Store Schema Name
 	writer.WriteString(enum_info.GetSchemaName());
 	// Store Enum Name
@@ -1387,7 +1402,7 @@ void EnumType::Serialize(FieldWriter &writer, const ExtraTypeInfo &type_info, bo
 		// Store Dictionary Size
 		writer.WriteField<uint32_t>(dict_size);
 		// Store Vector Order By Insertion
-		((Vector &)enum_info.GetValuesInsertOrder()).Serialize(dict_size, writer.GetSerializer());
+		((Vector &)enum_info.GetValuesInsertOrder()).Serialize(dict_size, writer.GetSerializer()); // NOLINT - FIXME
 	}
 }
 
@@ -1400,7 +1415,7 @@ struct EnumTypeInfoTemplated : public EnumTypeInfo {
 		UnifiedVectorFormat vdata;
 		values_insert_order.ToUnifiedFormat(size_p, vdata);
 
-		auto data = (string_t *)vdata.data;
+		auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
 		for (idx_t i = 0; i < size_p; i++) {
 			auto idx = vdata.sel->get_index(i);
 			if (!vdata.validity.RowIsValid(idx)) {
@@ -1428,7 +1443,7 @@ struct EnumTypeInfoTemplated : public EnumTypeInfo {
 		return make_shared<EnumTypeInfoTemplated>(std::move(enum_name), values_insert_order, size);
 	}
 
-	string_map_t<T> &GetValues() {
+	const string_map_t<T> &GetValues() const {
 		return values;
 	}
 
@@ -1443,7 +1458,7 @@ const string &EnumType::GetTypeName(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::ENUM);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
-	return ((EnumTypeInfo &)*info).GetEnumName();
+	return info->Cast<EnumTypeInfo>().GetEnumName();
 }
 
 static PhysicalType EnumVectorDictType(idx_t size) {
@@ -1480,7 +1495,7 @@ LogicalType LogicalType::ENUM(const string &enum_name, Vector &ordered_data, idx
 }
 
 template <class T>
-int64_t TemplatedGetPos(string_map_t<T> &map, const string_t &key) {
+int64_t TemplatedGetPos(const string_map_t<T> &map, const string_t &key) {
 	auto it = map.find(key);
 	if (it == map.end()) {
 		return -1;
@@ -1492,11 +1507,11 @@ int64_t EnumType::GetPos(const LogicalType &type, const string_t &key) {
 	auto info = type.AuxInfo();
 	switch (type.InternalType()) {
 	case PhysicalType::UINT8:
-		return TemplatedGetPos(((EnumTypeInfoTemplated<uint8_t> &)*info).GetValues(), key);
+		return TemplatedGetPos(info->Cast<EnumTypeInfoTemplated<uint8_t>>().GetValues(), key);
 	case PhysicalType::UINT16:
-		return TemplatedGetPos(((EnumTypeInfoTemplated<uint16_t> &)*info).GetValues(), key);
+		return TemplatedGetPos(info->Cast<EnumTypeInfoTemplated<uint16_t>>().GetValues(), key);
 	case PhysicalType::UINT32:
-		return TemplatedGetPos(((EnumTypeInfoTemplated<uint32_t> &)*info).GetValues(), key);
+		return TemplatedGetPos(info->Cast<EnumTypeInfoTemplated<uint32_t>>().GetValues(), key);
 	default:
 		throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
 	}
@@ -1504,7 +1519,7 @@ int64_t EnumType::GetPos(const LogicalType &type, const string_t &key) {
 
 const string EnumType::GetValue(const Value &val) {
 	auto info = val.type().AuxInfo();
-	auto &values_insert_order = ((EnumTypeInfo &)*info).GetValuesInsertOrder();
+	auto &values_insert_order = info->Cast<EnumTypeInfo>().GetValuesInsertOrder();
 	return StringValue::Get(values_insert_order.GetValue(val.GetValue<uint32_t>()));
 }
 
@@ -1512,14 +1527,14 @@ const Vector &EnumType::GetValuesInsertOrder(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::ENUM);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
-	return ((EnumTypeInfo &)*info).GetValuesInsertOrder();
+	return info->Cast<EnumTypeInfo>().GetValuesInsertOrder();
 }
 
 idx_t EnumType::GetSize(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::ENUM);
 	auto info = type.AuxInfo();
 	D_ASSERT(info);
-	return ((EnumTypeInfo &)*info).GetDictSize();
+	return info->Cast<EnumTypeInfo>().GetDictSize();
 }
 
 void EnumType::SetCatalog(LogicalType &type, optional_ptr<TypeCatalogEntry> catalog_entry) {
@@ -1535,7 +1550,7 @@ optional_ptr<TypeCatalogEntry> EnumType::GetCatalog(const LogicalType &type) {
 	if (!info) {
 		return nullptr;
 	}
-	return ((ExtraTypeInfo &)*info).catalog_entry;
+	return info->catalog_entry;
 }
 
 string EnumType::GetSchemaName(const LogicalType &type) {
@@ -1547,7 +1562,7 @@ PhysicalType EnumType::GetPhysicalType(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::ENUM);
 	auto aux_info = type.AuxInfo();
 	D_ASSERT(aux_info);
-	auto &info = (EnumTypeInfo &)*aux_info;
+	auto &info = aux_info->Cast<EnumTypeInfo>();
 	D_ASSERT(info.GetEnumDictType() == EnumDictType::VECTOR_DICT);
 	return EnumVectorDictType(info.GetDictSize());
 }

package/src/duckdb/src/common/vector_operations/boolean_operators.cpp

@@ -35,8 +35,8 @@ static void TemplatedBooleanNullmask(Vector &left, Vector &right, Vector &result
 		right.ToUnifiedFormat(count, rdata);
 
 		result.SetVectorType(VectorType::FLAT_VECTOR);
-		auto left_data = (uint8_t *)ldata.data; // we use uint8 to avoid load of gunk bools
-		auto right_data = (uint8_t *)rdata.data;
+		auto left_data = UnifiedVectorFormat::GetData<uint8_t>(ldata); // we use uint8 to avoid load of gunk bools
+		auto right_data = UnifiedVectorFormat::GetData<uint8_t>(rdata);
 		auto result_data = FlatVector::GetData<bool>(result);
 		auto &result_mask = FlatVector::Validity(result);
 		if (!ldata.validity.AllValid() || !rdata.validity.AllValid()) {

package/src/duckdb/src/common/vector_operations/is_distinct_from.cpp

@@ -11,7 +11,7 @@ struct DistinctBinaryLambdaWrapper {
 };
 
 template <class LEFT_TYPE, class RIGHT_TYPE, class RESULT_TYPE, class OP>
-static void DistinctExecuteGenericLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
+static void DistinctExecuteGenericLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
                                        RESULT_TYPE *__restrict result_data, const SelectionVector *__restrict lsel,
                                        const SelectionVector *__restrict rsel, idx_t count, ValidityMask &lmask,
                                        ValidityMask &rmask, ValidityMask &result_mask) {
@@ -49,8 +49,8 @@ static void DistinctExecuteGeneric(Vector &left, Vector &right, Vector &result,
 		result.SetVectorType(VectorType::FLAT_VECTOR);
 		auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
 		DistinctExecuteGenericLoop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP>(
-		    (LEFT_TYPE *)ldata.data, (RIGHT_TYPE *)rdata.data, result_data, ldata.sel, rdata.sel, count, ldata.validity,
-		    rdata.validity, FlatVector::Validity(result));
+		    UnifiedVectorFormat::GetData<LEFT_TYPE>(ldata), UnifiedVectorFormat::GetData<RIGHT_TYPE>(rdata),
+		    result_data, ldata.sel, rdata.sel, count, ldata.validity, rdata.validity, FlatVector::Validity(result));
 	}
 }
 
@@ -66,7 +66,7 @@ static void DistinctExecute(Vector &left, Vector &right, Vector &result, idx_t c
 
 template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL, bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
 static inline idx_t
-DistinctSelectGenericLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
+DistinctSelectGenericLoop(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
                           const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
                           const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lmask,
                           ValidityMask &rmask, SelectionVector *true_sel, SelectionVector *false_sel) {
@@ -105,7 +105,7 @@ DistinctSelectGenericLoop(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rd
 }
 template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool NO_NULL>
 static inline idx_t
-DistinctSelectGenericLoopSelSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
+DistinctSelectGenericLoopSelSwitch(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
                                    const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
                                    const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lmask,
                                    ValidityMask &rmask, SelectionVector *true_sel, SelectionVector *false_sel) {
@@ -124,7 +124,7 @@ DistinctSelectGenericLoopSelSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__re
 
 template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
 static inline idx_t
-DistinctSelectGenericLoopSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restrict rdata,
+DistinctSelectGenericLoopSwitch(const LEFT_TYPE *__restrict ldata, const RIGHT_TYPE *__restrict rdata,
                                 const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
                                 const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lmask,
                                 ValidityMask &rmask, SelectionVector *true_sel, SelectionVector *false_sel) {
@@ -145,9 +145,9 @@ static idx_t DistinctSelectGeneric(Vector &left, Vector &right, const SelectionV
 	left.ToUnifiedFormat(count, ldata);
 	right.ToUnifiedFormat(count, rdata);
 
-	return DistinctSelectGenericLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP>((LEFT_TYPE *)ldata.data, (RIGHT_TYPE *)rdata.data,
-	                                                                  ldata.sel, rdata.sel, sel, count, ldata.validity,
-	                                                                  rdata.validity, true_sel, false_sel);
+	return DistinctSelectGenericLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP>(
+	    UnifiedVectorFormat::GetData<LEFT_TYPE>(ldata), UnifiedVectorFormat::GetData<RIGHT_TYPE>(rdata), ldata.sel,
+	    rdata.sel, sel, count, ldata.validity, rdata.validity, true_sel, false_sel);
 }
 template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool LEFT_CONSTANT, bool RIGHT_CONSTANT, bool NO_NULL,
           bool HAS_TRUE_SEL, bool HAS_FALSE_SEL>
@@ -543,7 +543,7 @@ static idx_t DistinctSelectStruct(Vector &left, Vector &right, idx_t count, cons
 
 static void PositionListCursor(SelectionVector &cursor, UnifiedVectorFormat &vdata, const idx_t pos,
                                const SelectionVector &slice_sel, const idx_t count) {
-	const auto data = (const list_entry_t *)vdata.data;
+	const auto data = UnifiedVectorFormat::GetData<list_entry_t>(vdata);
 	for (idx_t i = 0; i < count; ++i) {
 		const auto slice_idx = slice_sel.get_index(i);
 
@@ -586,11 +586,11 @@ static idx_t DistinctSelectList(Vector &left, Vector &right, idx_t count, const
 	// Get pointers to the list entries
 	UnifiedVectorFormat lvdata;
 	left.ToUnifiedFormat(count, lvdata);
-	const auto ldata = (const list_entry_t *)lvdata.data;
+	const auto ldata = UnifiedVectorFormat::GetData<list_entry_t>(lvdata);
 
 	UnifiedVectorFormat rvdata;
 	right.ToUnifiedFormat(count, rvdata);
-	const auto rdata = (const list_entry_t *)rvdata.data;
+	const auto rdata = UnifiedVectorFormat::GetData<list_entry_t>(rvdata);
 
 	// In order to reuse the comparators, we have to track what passed and failed internally.
 	// To do that, we need local SVs that we then merge back into the real ones after every pass.

package/src/duckdb/src/common/vector_operations/vector_hash.cpp

@@ -25,7 +25,7 @@ static inline hash_t CombineHashScalar(hash_t a, hash_t b) {
 }
 
 template <bool HAS_RSEL, class T>
-static inline void TightLoopHash(T *__restrict ldata, hash_t *__restrict result_data, const SelectionVector *rsel,
+static inline void TightLoopHash(const T *__restrict ldata, hash_t *__restrict result_data, const SelectionVector *rsel,
                                  idx_t count, const SelectionVector *__restrict sel_vector, ValidityMask &mask) {
 	if (!mask.AllValid()) {
 		for (idx_t i = 0; i < count; i++) {
@@ -56,8 +56,8 @@ static inline void TemplatedLoopHash(Vector &input, Vector &result, const Select
 		UnifiedVectorFormat idata;
 		input.ToUnifiedFormat(count, idata);
 
-		TightLoopHash<HAS_RSEL, T>((T *)idata.data, FlatVector::GetData<hash_t>(result), rsel, count, idata.sel,
-		                           idata.validity);
+		TightLoopHash<HAS_RSEL, T>(UnifiedVectorFormat::GetData<T>(idata), FlatVector::GetData<hash_t>(result), rsel,
+		                           count, idata.sel, idata.validity);
 	}
 }
 
@@ -94,7 +94,7 @@ static inline void ListLoopHash(Vector &input, Vector &hashes, const SelectionVe
 
 	UnifiedVectorFormat idata;
 	input.ToUnifiedFormat(count, idata);
-	const auto ldata = (const list_entry_t *)idata.data;
+	const auto ldata = UnifiedVectorFormat::GetData<list_entry_t>(idata);
 
 	// Hash the children into a temporary
 	auto &child = ListVector::GetEntry(input);
@@ -240,8 +240,8 @@ void VectorOperations::Hash(Vector &input, Vector &result, const SelectionVector
 }
 
 template <bool HAS_RSEL, class T>
-static inline void TightLoopCombineHashConstant(T *__restrict ldata, hash_t constant_hash, hash_t *__restrict hash_data,
-                                                const SelectionVector *rsel, idx_t count,
+static inline void TightLoopCombineHashConstant(const T *__restrict ldata, hash_t constant_hash,
+                                                hash_t *__restrict hash_data, const SelectionVector *rsel, idx_t count,
                                                 const SelectionVector *__restrict sel_vector, ValidityMask &mask) {
 	if (!mask.AllValid()) {
 		for (idx_t i = 0; i < count; i++) {
@@ -261,8 +261,9 @@ static inline void TightLoopCombineHashConstant(T *__restrict ldata, hash_t cons
 }
 
 template <bool HAS_RSEL, class T>
-static inline void TightLoopCombineHash(T *__restrict ldata, hash_t *__restrict hash_data, const SelectionVector *rsel,
-                                        idx_t count, const SelectionVector *__restrict sel_vector, ValidityMask &mask) {
+static inline void TightLoopCombineHash(const T *__restrict ldata, hash_t *__restrict hash_data,
+                                        const SelectionVector *rsel, idx_t count,
+                                        const SelectionVector *__restrict sel_vector, ValidityMask &mask) {
 	if (!mask.AllValid()) {
 		for (idx_t i = 0; i < count; i++) {
 			auto ridx = HAS_RSEL ? rsel->get_index(i) : i;
@@ -296,13 +297,14 @@ void TemplatedLoopCombineHash(Vector &input, Vector &hashes, const SelectionVect
 			auto constant_hash = *ConstantVector::GetData<hash_t>(hashes);
 			// now re-initialize the hashes vector to an empty flat vector
 			hashes.SetVectorType(VectorType::FLAT_VECTOR);
-			TightLoopCombineHashConstant<HAS_RSEL, T>((T *)idata.data, constant_hash,
+			TightLoopCombineHashConstant<HAS_RSEL, T>(UnifiedVectorFormat::GetData<T>(idata), constant_hash,
 			                                          FlatVector::GetData<hash_t>(hashes), rsel, count, idata.sel,
 			                                          idata.validity);
 		} else {
 			D_ASSERT(hashes.GetVectorType() == VectorType::FLAT_VECTOR);
-			TightLoopCombineHash<HAS_RSEL, T>((T *)idata.data, FlatVector::GetData<hash_t>(hashes), rsel, count,
-			                                  idata.sel, idata.validity);
+			TightLoopCombineHash<HAS_RSEL, T>(UnifiedVectorFormat::GetData<T>(idata),
+			                                  FlatVector::GetData<hash_t>(hashes), rsel, count, idata.sel,
+			                                  idata.validity);
 		}
 	}
 }

package/src/duckdb/src/common/vector_operations/vector_storage.cpp

@@ -6,7 +6,7 @@ namespace duckdb {
 
 template <class T>
 static void CopyToStorageLoop(UnifiedVectorFormat &vdata, idx_t count, data_ptr_t target) {
-	auto ldata = (T *)vdata.data;
+	auto ldata = UnifiedVectorFormat::GetData<T>(vdata);
 	auto result_data = (T *)target;
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = vdata.sel->get_index(i);

package/src/duckdb/src/core_functions/aggregate/algebraic/avg.cpp

@@ -59,21 +59,21 @@ public:
 
 struct AverageSetOperation {
 	template <class STATE>
-	static void Initialize(STATE *state) {
-		state->Initialize();
+	static void Initialize(STATE &state) {
+		state.Initialize();
 	}
 	template <class STATE>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
-		target->Combine(source);
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		target.Combine(source);
 	}
 	template <class STATE>
-	static void AddValues(STATE *state, idx_t count) {
-		state->count += count;
+	static void AddValues(STATE &state, idx_t count) {
+		state.count += count;
 	}
 };
 
 template <class T>
-static T GetAverageDivident(uint64_t count, FunctionData *bind_data) {
+static T GetAverageDivident(uint64_t count, optional_ptr<FunctionData> bind_data) {
 	T divident = T(count);
 	if (bind_data) {
 		auto &avg_bind_data = bind_data->Cast<AverageDecimalBindData>();
@@ -84,61 +84,58 @@ static T GetAverageDivident(uint64_t count, FunctionData *bind_data) {
 
 struct IntegerAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
 	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->count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			double divident = GetAverageDivident<double>(state->count, aggr_input_data.bind_data);
-			target[idx] = double(state->value) / divident;
+			double divident = GetAverageDivident<double>(state.count, finalize_data.input.bind_data);
+			target = double(state.value) / divident;
 		}
 	}
 };
 
 struct IntegerAverageOperationHugeint : public BaseSumOperation<AverageSetOperation, HugeintAdd> {
 	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->count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			long double divident = GetAverageDivident<long double>(state->count, aggr_input_data.bind_data);
-			target[idx] = Hugeint::Cast<long double>(state->value) / divident;
+			long double divident = GetAverageDivident<long double>(state.count, finalize_data.input.bind_data);
+			target = Hugeint::Cast<long double>(state.value) / divident;
 		}
 	}
 };
 
 struct HugeintAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
 	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->count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			long double divident = GetAverageDivident<long double>(state->count, aggr_input_data.bind_data);
-			target[idx] = Hugeint::Cast<long double>(state->value) / divident;
+			long double divident = GetAverageDivident<long double>(state.count, finalize_data.input.bind_data);
+			target = Hugeint::Cast<long double>(state.value) / divident;
 		}
 	}
 };
 
 struct NumericAverageOperation : public BaseSumOperation<AverageSetOperation, RegularAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = (state->value / state->count);
+			target = state.value / state.count;
 		}
 	}
 };
 
 struct KahanAverageOperation : public BaseSumOperation<AverageSetOperation, KahanAdd> {
 	template <class T, class STATE>
-	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
-		if (state->count == 0) {
-			mask.SetInvalid(idx);
+	static void Finalize(STATE &state, T &target, AggregateFinalizeData &finalize_data) {
+		if (state.count == 0) {
+			finalize_data.ReturnNull();
 		} else {
-			target[idx] = (state->value / state->count) + (state->err / state->count);
+			target = (state.value / state.count) + (state.err / state.count);
 		}
 	}
 };

package/src/duckdb/src/core_functions/aggregate/algebraic/covar.cpp

@@ -1,10 +1,6 @@
 #include "duckdb/core_functions/aggregate/algebraic_functions.hpp"
-#include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/function/function_set.hpp"
 #include "duckdb/core_functions/aggregate/algebraic/covar.hpp"
-#include <cmath>
 
 namespace duckdb {