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

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

@@ -811,6 +811,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 +899,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 +908,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 +976,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 +1016,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 +1025,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 +1077,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 +1133,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 +1144,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 +1153,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 +1165,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 +1288,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 +1297,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 +1317,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 +1338,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 +1371,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 +1385,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 +1398,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 +1411,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 +1439,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 +1454,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 +1491,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 +1503,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 +1515,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 +1523,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 +1546,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 +1558,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/distributive/approx_count.cpp

@@ -69,7 +69,7 @@ static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], AggregateIn
                                                     data_ptr_t state, idx_t count) {
 	D_ASSERT(input_count == 1);
 
-	auto agg_state = (ApproxDistinctCountState *)state;
+	auto agg_state = reinterpret_cast<ApproxDistinctCountState *>(state);
 	if (!agg_state->log) {
 		agg_state->log = new HyperLogLog();
 	}
@@ -91,7 +91,7 @@ static void ApproxCountDistinctUpdateFunction(Vector inputs[], AggregateInputDat
 
 	UnifiedVectorFormat sdata;
 	state_vector.ToUnifiedFormat(count, sdata);
-	auto states = (ApproxDistinctCountState **)sdata.data;
+	auto states = UnifiedVectorFormat::GetDataNoConst<ApproxDistinctCountState *>(sdata);
 
 	uint64_t *indices = nullptr;
 	uint8_t *counts = nullptr;
@@ -111,7 +111,7 @@ static void ApproxCountDistinctUpdateFunction(Vector inputs[], AggregateInputDat
 	inputs[0].ToUnifiedFormat(count, vdata);
 
 	HyperLogLog::ProcessEntries(vdata, inputs[0].GetType(), indices, counts, count);
-	HyperLogLog::AddToLogs(vdata, count, indices, counts, (HyperLogLog ***)states, sdata.sel);
+	HyperLogLog::AddToLogs(vdata, count, indices, counts, reinterpret_cast<HyperLogLog ***>(states), sdata.sel);
 }
 
 AggregateFunction GetApproxCountDistinctFunction(const LogicalType &input_type) {

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

@@ -108,8 +108,8 @@ struct ArgMinMaxBase {
 	}
 
 	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) {
 		if (!state->is_initialized) {
 			STATE::template AssignValue<A_TYPE>(state->arg, x_data[xidx], false);
 			STATE::template AssignValue<B_TYPE>(state->value, y_data[yidx], false);
@@ -176,7 +176,7 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
 		auto &by = inputs[1];
 		UnifiedVectorFormat bdata;
 		by.ToUnifiedFormat(count, bdata);
-		const auto bys = (BY_TYPE *)bdata.data;
+		const auto bys = UnifiedVectorFormat::GetData<BY_TYPE>(bdata);
 
 		UnifiedVectorFormat sdata;
 		state_vector.ToUnifiedFormat(count, sdata);

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

@@ -48,7 +48,7 @@ struct BitwiseOperation {
 	}
 
 	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->is_set) {
 			OP::template Assign(state, input[idx]);
 			state->is_set = true;
@@ -58,7 +58,7 @@ struct BitwiseOperation {
 	}
 
 	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) {
 		OP::template Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 	}
@@ -118,7 +118,7 @@ struct BitXorOperation : public BitwiseOperation {
 	}
 
 	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);
@@ -181,7 +181,7 @@ struct BitStringXorOperation : public BitStringBitwiseOperation {
 	}
 
 	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/bitstring_agg.cpp

@@ -53,18 +53,19 @@ struct BitStringAggOperation {
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>
-	static void Operation(STATE *state, AggregateInputData &data, INPUT_TYPE *input, ValidityMask &mask, idx_t idx) {
-		auto bind_agg_data = (BitstringAggBindData *)data.bind_data;
+	static void Operation(STATE *state, AggregateInputData &data, const INPUT_TYPE *input, ValidityMask &mask,
+	                      idx_t idx) {
+		auto &bind_agg_data = data.bind_data->template Cast<BitstringAggBindData>();
 		if (!state->is_set) {
-			if (bind_agg_data->min.IsNull() || bind_agg_data->max.IsNull()) {
+			if (bind_agg_data.min.IsNull() || bind_agg_data.max.IsNull()) {
 				throw BinderException(
 				    "Could not retrieve required statistics. Alternatively, try by providing the statistics "
 				    "explicitly: BITSTRING_AGG(col, min, max) ");
 			}
-			state->min = bind_agg_data->min.GetValue<INPUT_TYPE>();
-			state->max = bind_agg_data->max.GetValue<INPUT_TYPE>();
+			state->min = bind_agg_data.min.GetValue<INPUT_TYPE>();
+			state->max = bind_agg_data.max.GetValue<INPUT_TYPE>();
 			idx_t bit_range =
-			    GetRange(bind_agg_data->min.GetValue<INPUT_TYPE>(), bind_agg_data->max.GetValue<INPUT_TYPE>());
+			    GetRange(bind_agg_data.min.GetValue<INPUT_TYPE>(), bind_agg_data.max.GetValue<INPUT_TYPE>());
 			if (bit_range > MAX_BIT_RANGE) {
 				throw OutOfRangeException(
 				    "The range between min and max value (%s <-> %s) is too large for bitstring aggregation",
@@ -78,7 +79,7 @@ struct BitStringAggOperation {
 			state->is_set = true;
 		}
 		if (input[idx] >= state->min && input[idx] <= state->max) {
-			Execute(state, input[idx], bind_agg_data->min.GetValue<INPUT_TYPE>());
+			Execute(state, input[idx], bind_agg_data.min.GetValue<INPUT_TYPE>());
 		} else {
 			throw OutOfRangeException("Value %s is outside of provided min and max range (%s <-> %s)",
 			                          NumericHelper::ToString(input[idx]), NumericHelper::ToString(state->min),
@@ -87,7 +88,7 @@ struct BitStringAggOperation {
 	}
 
 	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) {
 		OP::template Operation<INPUT_TYPE, STATE, OP>(state, aggr_input_data, input, mask, 0);
 	}
@@ -190,9 +191,9 @@ unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, Bound
 		throw BinderException("Could not retrieve required statistics. Alternatively, try by providing the statistics "
 		                      "explicitly: BITSTRING_AGG(col, min, max) ");
 	}
-	auto bind_agg_data = (BitstringAggBindData *)input.bind_data;
-	bind_agg_data->min = NumericStats::Min(input.child_stats[0]);
-	bind_agg_data->max = NumericStats::Max(input.child_stats[0]);
+	auto &bind_agg_data = input.bind_data->Cast<BitstringAggBindData>();
+	bind_agg_data.min = NumericStats::Min(input.child_stats[0]);
+	bind_agg_data.max = NumericStats::Max(input.child_stats[0]);
 	return nullptr;
 }
 

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

@@ -34,13 +34,13 @@ struct BoolAndFunFunction {
 	}
 
 	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) {
 		state->empty = false;
 		state->val = input[idx] && state->val;
 	}
 
 	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);
@@ -73,7 +73,7 @@ struct BoolOrFunFunction {
 		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) {
 		state->empty = false;
 		state->val = input[idx] || state->val;
 	}

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

@@ -75,7 +75,7 @@ struct EntropyFunctionBase {
 
 struct EntropyFunction : EntropyFunctionBase {
 	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->distinct) {
 			state->distinct = new unordered_map<INPUT_TYPE, idx_t>();
 		}
@@ -93,7 +93,7 @@ struct EntropyFunction : EntropyFunctionBase {
 
 struct EntropyFunctionString : EntropyFunctionBase {
 	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->distinct) {
 			state->distinct = new unordered_map<string, idx_t>();
 		}
@@ -103,7 +103,7 @@ struct EntropyFunctionString : EntropyFunctionBase {
 	}
 
 	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);