duckdb 0.8.1-dev26.0 → 0.8.1-dev276.0

package/src/duckdb/src/function/cast/list_casts.cpp

@@ -51,12 +51,10 @@ bool ListCast::ListToListCast(Vector &source, Vector &result, idx_t count, CastP
 	auto &append_vector = ListVector::GetEntry(result);
 
 	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
-	if (!cast_data.child_cast_info.function(source_cc, append_vector, source_size, child_parameters)) {
-		return false;
-	}
+	bool all_succeeded = cast_data.child_cast_info.function(source_cc, append_vector, source_size, child_parameters);
 	ListVector::SetListSize(result, source_size);
 	D_ASSERT(ListVector::GetListSize(result) == source_size);
-	return true;
+	return all_succeeded;
 }
 
 static bool ListToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {

package/src/duckdb/src/function/cast/string_cast.cpp

@@ -8,7 +8,7 @@
 namespace duckdb {
 
 template <class T>
-bool StringEnumCastLoop(string_t *source_data, ValidityMask &source_mask, const LogicalType &source_type,
+bool StringEnumCastLoop(const string_t *source_data, ValidityMask &source_mask, const LogicalType &source_type,
                         T *result_data, ValidityMask &result_mask, const LogicalType &result_type, idx_t count,
                         string *error_message, const SelectionVector *sel) {
 	bool all_converted = true;
@@ -55,7 +55,7 @@ bool StringEnumCast(Vector &source, Vector &result, idx_t count, CastParameters
 
 		result.SetVectorType(VectorType::FLAT_VECTOR);
 
-		auto source_data = (string_t *)vdata.data;
+		auto source_data = UnifiedVectorFormat::GetData<string_t>(vdata);
 		auto source_sel = vdata.sel;
 		auto source_mask = vdata.validity;
 		auto result_data = FlatVector::GetData<T>(result);
@@ -119,9 +119,9 @@ static BoundCastInfo VectorStringCastNumericSwitch(BindCastInput &input, const L
 //===--------------------------------------------------------------------===//
 // string -> list casting
 //===--------------------------------------------------------------------===//
-bool VectorStringToList::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
-                                                    ValidityMask &result_mask, idx_t count, CastParameters &parameters,
-                                                    const SelectionVector *sel) {
+bool VectorStringToList::StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask,
+                                                    Vector &result, ValidityMask &result_mask, idx_t count,
+                                                    CastParameters &parameters, const SelectionVector *sel) {
 	idx_t total_list_size = 0;
 	for (idx_t i = 0; i < count; i++) {
 		idx_t idx = i;
@@ -183,8 +183,8 @@ static LogicalType InitVarcharStructType(const LogicalType &target) {
 //===--------------------------------------------------------------------===//
 // string -> struct casting
 //===--------------------------------------------------------------------===//
-bool VectorStringToStruct::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
-                                                      ValidityMask &result_mask, idx_t count,
+bool VectorStringToStruct::StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask,
+                                                      Vector &result, ValidityMask &result_mask, idx_t count,
                                                       CastParameters &parameters, const SelectionVector *sel) {
 	auto varchar_struct_type = InitVarcharStructType(result.GetType());
 	Vector varchar_vector(varchar_struct_type, count);
@@ -253,9 +253,9 @@ unique_ptr<FunctionLocalState> InitMapCastLocalState(CastLocalStateParameters &p
 	return std::move(result);
 }
 
-bool VectorStringToMap::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
-                                                   ValidityMask &result_mask, idx_t count, CastParameters &parameters,
-                                                   const SelectionVector *sel) {
+bool VectorStringToMap::StringToNestedTypeCastLoop(const string_t *source_data, ValidityMask &source_mask,
+                                                   Vector &result, ValidityMask &result_mask, idx_t count,
+                                                   CastParameters &parameters, const SelectionVector *sel) {
 	idx_t total_elements = 0;
 	for (idx_t i = 0; i < count; i++) {
 		idx_t idx = i;
@@ -352,7 +352,7 @@ bool StringToNestedTypeCast(Vector &source, Vector &result, idx_t count, CastPar
 
 		source.ToUnifiedFormat(count, unified_source);
 		auto source_sel = unified_source.sel;
-		auto source_data = (string_t *)unified_source.data;
+		auto source_data = UnifiedVectorFormat::GetData<string_t>(unified_source);
 		auto &source_mask = unified_source.validity;
 		auto &result_mask = FlatVector::Validity(result);
 

package/src/duckdb/src/function/cast/union_casts.cpp

@@ -293,7 +293,7 @@ static bool UnionToUnionCast(Vector &source, Vector &result, idx_t count, CastPa
 			auto source_row_idx = source_tag_format.sel->get_index(row_idx);
 			if (source_tag_format.validity.RowIsValid(source_row_idx)) {
 				// map the tag
-				auto source_tag = ((union_tag_t *)source_tag_format.data)[source_row_idx];
+				auto source_tag = (UnifiedVectorFormat::GetData<union_tag_t>(source_tag_format))[source_row_idx];
 				auto target_tag = cast_data.tag_map[source_tag];
 				FlatVector::GetData<union_tag_t>(result_tag_vector)[row_idx] = target_tag;
 			} else {
@@ -339,7 +339,7 @@ static bool UnionToVarcharCast(Vector &source, Vector &result, idx_t count, Cast
 		auto mapped_idx = member_vdata.sel->get_index(i);
 		auto member_valid = member_vdata.validity.RowIsValid(mapped_idx);
 		if (member_valid) {
-			auto member_str = ((string_t *)member_vdata.data)[mapped_idx];
+			auto member_str = (UnifiedVectorFormat::GetData<string_t>(member_vdata))[mapped_idx];
 			result_data[i] = StringVector::AddString(result, member_str);
 		} else {
 			result_data[i] = StringVector::AddString(result, "NULL");

package/src/duckdb/src/function/cast/vector_cast_helpers.cpp

@@ -299,8 +299,9 @@ static bool FindValueStruct(const char *buf, idx_t len, idx_t &pos, Vector &varc
 	return false;
 }
 
-bool VectorStringToStruct::SplitStruct(string_t &input, vector<unique_ptr<Vector>> &varchar_vectors, idx_t &row_idx,
-                                       string_map_t<idx_t> &child_names, vector<ValidityMask *> &child_masks) {
+bool VectorStringToStruct::SplitStruct(const string_t &input, vector<unique_ptr<Vector>> &varchar_vectors,
+                                       idx_t &row_idx, string_map_t<idx_t> &child_names,
+                                       vector<ValidityMask *> &child_masks) {
 	const char *buf = input.GetData();
 	idx_t len = input.GetSize();
 	idx_t pos = 0;

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -18,21 +18,18 @@ string PragmaTableInfo(ClientContext &context, const FunctionParameters &paramet
 }
 
 string PragmaShowTables(ClientContext &context, const FunctionParameters &parameters) {
-	auto catalog = DatabaseManager::GetDefaultDatabase(context);
-	auto schema = ClientData::Get(context).catalog_search_path->GetDefault().schema;
-	schema = (schema == INVALID_SCHEMA) ? DEFAULT_SCHEMA : schema; // NOLINT
-
-	auto where_clause = StringUtil::Format("where ((database_name = '%s') and (schema_name = '%s'))", catalog, schema);
 	// clang-format off
-	auto pragma_query = StringUtil::Format(R"EOF(
+	return R"EOF(
 	with "tables" as
 	(
 		SELECT table_name as "name"
-		FROM duckdb_tables %s
+		FROM duckdb_tables
+		where in_search_path(database_name, schema_name)
 	), "views" as
 	(
 		SELECT view_name as "name"
-		FROM duckdb_views %s
+		FROM duckdb_views
+		where in_search_path(database_name, schema_name)
 	), db_objects as
 	(
 		SELECT "name" FROM "tables"
@@ -41,26 +38,39 @@ string PragmaShowTables(ClientContext &context, const FunctionParameters &parame
 	)
 	SELECT "name"
 	FROM db_objects
-	ORDER BY "name";)EOF", where_clause, where_clause);
+	ORDER BY "name";)EOF";
 	// clang-format on
-
-	return pragma_query;
 }
 
 string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters &parameters) {
 	return R"(
-			SELECT
-				t.database_name AS database,
-				t.schema_name AS schema,
-				t.table_name,
-				LIST(c.column_name order by c.column_index) AS column_names,
-				LIST(c.data_type order by c.column_index) AS column_types,
-				FIRST(t.temporary) AS temporary,
-			FROM duckdb_tables t
-			JOIN duckdb_columns c
-			USING (table_oid)
-			GROUP BY t.database_name, t.schema_name, t.table_name
-			ORDER BY t.database_name, t.schema_name, t.table_name;
+	SELECT
+		t.database_name AS database,
+		t.schema_name AS schema,
+		t.table_name AS name,
+		LIST(c.column_name order by c.column_index) AS column_names,
+		LIST(c.data_type order by c.column_index) AS column_types,
+		FIRST(t.temporary) AS temporary,
+	FROM duckdb_tables t
+	JOIN duckdb_columns c
+	USING (table_oid)
+	GROUP BY database, schema, name
+
+	UNION ALL
+
+	SELECT
+		v.database_name AS database,
+		v.schema_name AS schema,
+		v.view_name AS name,
+		LIST(c.column_name order by c.column_index) AS column_names,
+		LIST(c.data_type order by c.column_index) AS column_types,
+		FIRST(v.temporary) AS temporary,
+	FROM duckdb_views v
+	JOIN duckdb_columns c
+	ON (v.view_oid=c.table_oid)
+	GROUP BY database, schema, name
+
+	ORDER BY database, schema, name
 	)";
 }
 

package/src/duckdb/src/function/scalar/generic/constant_or_null.cpp

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

package/src/duckdb/src/function/scalar/list/list_concat.cpp

@@ -25,8 +25,8 @@ static void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &
 	UnifiedVectorFormat rhs_data;
 	lhs.ToUnifiedFormat(count, lhs_data);
 	rhs.ToUnifiedFormat(count, rhs_data);
-	auto lhs_entries = (list_entry_t *)lhs_data.data;
-	auto rhs_entries = (list_entry_t *)rhs_data.data;
+	auto lhs_entries = UnifiedVectorFormat::GetData<list_entry_t>(lhs_data);
+	auto rhs_entries = UnifiedVectorFormat::GetData<list_entry_t>(rhs_data);
 
 	auto lhs_list_size = ListVector::GetListSize(lhs);
 	auto rhs_list_size = ListVector::GetListSize(rhs);

package/src/duckdb/src/function/scalar/list/list_extract.cpp

@@ -32,7 +32,7 @@ void ListExtractTemplate(idx_t count, UnifiedVectorFormat &list_data, UnifiedVec
 
 	// this is lifted from ExecuteGenericLoop because we can't push the list child data into this otherwise
 	// should have gone with GetValue perhaps
-	auto child_data = (T *)child_format.data;
+	auto child_data = UnifiedVectorFormat::GetData<T>(child_format);
 	for (idx_t i = 0; i < count; i++) {
 		auto list_index = list_data.sel->get_index(i);
 		auto offsets_index = offsets_data.sel->get_index(i);
@@ -44,8 +44,8 @@ void ListExtractTemplate(idx_t count, UnifiedVectorFormat &list_data, UnifiedVec
 			result_mask.SetInvalid(i);
 			continue;
 		}
-		auto list_entry = ((list_entry_t *)list_data.data)[list_index];
-		auto offsets_entry = ((int64_t *)offsets_data.data)[offsets_index];
+		auto list_entry = (UnifiedVectorFormat::GetData<list_entry_t>(list_data))[list_index];
+		auto offsets_entry = (UnifiedVectorFormat::GetData<int64_t>(offsets_data))[offsets_index];
 
 		// 1-based indexing
 		if (offsets_entry == 0) {

package/src/duckdb/src/function/scalar/operators/arithmetic.cpp

@@ -249,9 +249,8 @@ unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFu
 
 static void SerializeDecimalArithmetic(FieldWriter &writer, const FunctionData *bind_data_p,
                                        const ScalarFunction &function) {
-	D_ASSERT(bind_data_p);
-	auto bind_data = (DecimalArithmeticBindData *)bind_data_p;
-	writer.WriteField(bind_data->check_overflow);
+	auto &bind_data = bind_data_p->Cast<DecimalArithmeticBindData>();
+	writer.WriteField(bind_data.check_overflow);
 	writer.WriteSerializable(function.return_type);
 	writer.WriteRegularSerializableList(function.arguments);
 }

package/src/duckdb/src/function/scalar/string/concat.cpp

@@ -31,7 +31,7 @@ static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &resu
 			UnifiedVectorFormat vdata;
 			input.ToUnifiedFormat(args.size(), vdata);
 
-			auto input_data = (string_t *)vdata.data;
+			auto input_data = UnifiedVectorFormat::GetData<string_t>(vdata);
 			// now add the length of each vector to the result length
 			for (idx_t i = 0; i < args.size(); i++) {
 				auto idx = vdata.sel->get_index(i);
@@ -77,7 +77,7 @@ static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &resu
 			UnifiedVectorFormat idata;
 			input.ToUnifiedFormat(args.size(), idata);
 
-			auto input_data = (string_t *)idata.data;
+			auto input_data = UnifiedVectorFormat::GetData<string_t>(idata);
 			for (idx_t i = 0; i < args.size(); i++) {
 				auto idx = idata.sel->get_index(i);
 				if (!idata.validity.RowIsValid(idx)) {
@@ -114,7 +114,7 @@ static void ConcatOperator(DataChunk &args, ExpressionState &state, Vector &resu
 	    });
 }
 
-static void TemplatedConcatWS(DataChunk &args, string_t *sep_data, const SelectionVector &sep_sel,
+static void TemplatedConcatWS(DataChunk &args, const string_t *sep_data, const SelectionVector &sep_sel,
                               const SelectionVector &rsel, idx_t count, Vector &result) {
 	vector<idx_t> result_lengths(args.size(), 0);
 	vector<bool> has_results(args.size(), false);
@@ -127,7 +127,7 @@ static void TemplatedConcatWS(DataChunk &args, string_t *sep_data, const Selecti
 	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
 		auto &idata = orrified_data[col_idx - 1];
 
-		auto input_data = (string_t *)idata.data;
+		auto input_data = UnifiedVectorFormat::GetData<string_t>(idata);
 		for (idx_t i = 0; i < count; i++) {
 			auto ridx = rsel.get_index(i);
 			auto sep_idx = sep_sel.get_index(ridx);
@@ -157,7 +157,7 @@ static void TemplatedConcatWS(DataChunk &args, string_t *sep_data, const Selecti
 	// now that the empty space for the strings has been allocated, perform the concatenation
 	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
 		auto &idata = orrified_data[col_idx - 1];
-		auto input_data = (string_t *)idata.data;
+		auto input_data = UnifiedVectorFormat::GetData<string_t>(idata);
 		for (idx_t i = 0; i < count; i++) {
 			auto ridx = rsel.get_index(i);
 			auto sep_idx = sep_sel.get_index(ridx);
@@ -206,7 +206,7 @@ static void ConcatWSFunction(DataChunk &args, ExpressionState &state, Vector &re
 		}
 		// no null values
 		auto sel = FlatVector::IncrementalSelectionVector();
-		TemplatedConcatWS(args, (string_t *)vdata.data, *vdata.sel, *sel, args.size(), result);
+		TemplatedConcatWS(args, UnifiedVectorFormat::GetData<string_t>(vdata), *vdata.sel, *sel, args.size(), result);
 		return;
 	}
 	default: {
@@ -221,7 +221,8 @@ static void ConcatWSFunction(DataChunk &args, ExpressionState &state, Vector &re
 				not_null_vector.set_index(not_null_count++, i);
 			}
 		}
-		TemplatedConcatWS(args, (string_t *)vdata.data, *vdata.sel, not_null_vector, not_null_count, result);
+		TemplatedConcatWS(args, UnifiedVectorFormat::GetData<string_t>(vdata), *vdata.sel, not_null_vector,
+		                  not_null_count, result);
 		return;
 	}
 	}

package/src/duckdb/src/function/scalar/string/contains.cpp

@@ -106,9 +106,9 @@ idx_t ContainsFun::Find(const unsigned char *haystack, idx_t haystack_size, cons
 	if (location == nullptr) {
 		return DConstants::INVALID_INDEX;
 	}
-	idx_t base_offset = (const unsigned char *)location - haystack;
+	idx_t base_offset = const_uchar_ptr_cast(location) - haystack;
 	haystack_size -= base_offset;
-	haystack = (const unsigned char *)location;
+	haystack = const_uchar_ptr_cast(location);
 	// switch algorithm depending on needle size
 	switch (needle_size) {
 	case 1:
@@ -133,9 +133,9 @@ idx_t ContainsFun::Find(const unsigned char *haystack, idx_t haystack_size, cons
 }
 
 idx_t ContainsFun::Find(const string_t &haystack_s, const string_t &needle_s) {
-	auto haystack = (const unsigned char *)haystack_s.GetData();
+	auto haystack = const_uchar_ptr_cast(haystack_s.GetData());
 	auto haystack_size = haystack_s.GetSize();
-	auto needle = (const unsigned char *)needle_s.GetData();
+	auto needle = const_uchar_ptr_cast(needle_s.GetData());
 	auto needle_size = needle_s.GetSize();
 	if (needle_size == 0) {
 		// empty needle: always true

package/src/duckdb/src/function/scalar/string/like.cpp

@@ -78,7 +78,7 @@ struct LikeMatcher : public FunctionData {
 	}
 
 	bool Match(string_t &str) {
-		auto str_data = (const unsigned char *)str.GetData();
+		auto str_data = const_uchar_ptr_cast(str.GetData());
 		auto str_len = str.GetSize();
 		idx_t segment_idx = 0;
 		idx_t end_idx = segments.size() - 1;
@@ -105,7 +105,7 @@ struct LikeMatcher : public FunctionData {
 		for (; segment_idx < end_idx; segment_idx++) {
 			auto &segment = segments[segment_idx];
 			// find the pattern of the current segment
-			idx_t next_offset = ContainsFun::Find(str_data, str_len, (const unsigned char *)segment.pattern.c_str(),
+			idx_t next_offset = ContainsFun::Find(str_data, str_len, const_uchar_ptr_cast(segment.pattern.c_str()),
 			                                      segment.pattern.size());
 			if (next_offset == DConstants::INVALID_INDEX) {
 				// could not find this pattern in the string: no match
@@ -130,7 +130,7 @@ struct LikeMatcher : public FunctionData {
 		} else {
 			auto &segment = segments.back();
 			// find the pattern of the current segment
-			idx_t next_offset = ContainsFun::Find(str_data, str_len, (const unsigned char *)segment.pattern.c_str(),
+			idx_t next_offset = ContainsFun::Find(str_data, str_len, const_uchar_ptr_cast(segment.pattern.c_str()),
 			                                      segment.pattern.size());
 			return next_offset != DConstants::INVALID_INDEX;
 		}
@@ -179,7 +179,7 @@ struct LikeMatcher : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const LikeMatcher &)other_p;
+		auto &other = other_p.Cast<LikeMatcher>();
 		return like_pattern == other.like_pattern;
 	}
 
@@ -491,7 +491,7 @@ template <class OP, bool INVERT>
 static void RegularLikeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	if (func_expr.bind_info) {
-		auto &matcher = (LikeMatcher &)*func_expr.bind_info;
+		auto &matcher = func_expr.bind_info->Cast<LikeMatcher>();
 		// use fast like matcher
 		UnaryExecutor::Execute<string_t, bool>(input.data[0], result, input.size(), [&](string_t input) {
 			return INVERT ? !matcher.Match(input) : matcher.Match(input);

package/src/duckdb/src/function/scalar/string/regexp/regexp_extract_all.cpp

@@ -94,7 +94,7 @@ void ExtractSingleTuple(const string_t &string, duckdb_re2::RE2 &pattern, int32_
 		} else {
 			// Every group is a substring of the original, we can find out the offset using the pointer
 			// the 'match_group' address is guaranteed to be bigger than that of the source
-			D_ASSERT((const char *)match_group.begin() >= string.GetData());
+			D_ASSERT(const_char_ptr_cast(match_group.begin()) >= string.GetData());
 			idx_t offset = match_group.begin() - string.GetData();
 			list_content[child_idx] = string_t(string.GetData() + offset, match_group.size());
 		}
@@ -119,7 +119,7 @@ int32_t GetGroupIndex(DataChunk &args, idx_t row, int32_t &result) {
 	if (!format.validity.RowIsValid(index)) {
 		return false;
 	}
-	result = ((int32_t *)format.data)[index];
+	result = UnifiedVectorFormat::GetData<int32_t>(format)[index];
 	return true;
 }
 
@@ -188,7 +188,7 @@ void RegexpExtractAll::Execute(DataChunk &args, ExpressionState &state, Vector &
 			if (!pattern_data.validity.RowIsValid(pattern_idx)) {
 				pattern_valid = false;
 			} else {
-				auto &pattern_p = ((string_t *)pattern_data.data)[pattern_idx];
+				auto &pattern_p = UnifiedVectorFormat::GetData<string_t>(pattern_data)[pattern_idx];
 				auto pattern_strpiece = CreateStringPiece(pattern_p);
 				stored_re = make_uniq<duckdb_re2::RE2>(pattern_strpiece, info.options);
 
@@ -216,7 +216,7 @@ void RegexpExtractAll::Execute(DataChunk &args, ExpressionState &state, Vector &
 
 		auto &re = GetPattern(info, state, stored_re);
 		auto &groups = GetGroupsBuffer(info, state, non_const_args);
-		auto &string = ((string_t *)strings_data.data)[string_idx];
+		auto &string = UnifiedVectorFormat::GetData<string_t>(strings_data)[string_idx];
 		ExtractSingleTuple(string, re, group_index, groups, result, row);
 	}
 

package/src/duckdb/src/function/scalar/string/regexp/regexp_util.cpp

@@ -69,9 +69,13 @@ void ParseRegexOptions(ClientContext &context, Expression &expr, RE2::Options &t
 		throw InvalidInputException("Regex options field must be a constant");
 	}
 	Value options_str = ExpressionExecutor::EvaluateScalar(context, expr);
-	if (!options_str.IsNull() && options_str.type().id() == LogicalTypeId::VARCHAR) {
-		ParseRegexOptions(StringValue::Get(options_str), target, global_replace);
+	if (options_str.IsNull()) {
+		throw InvalidInputException("Regex options field must not be NULL");
 	}
+	if (options_str.type().id() != LogicalTypeId::VARCHAR) {
+		throw InvalidInputException("Regex options field must be a string");
+	}
+	ParseRegexOptions(StringValue::Get(options_str), target, global_replace);
 }
 
 } // namespace regexp_util

package/src/duckdb/src/function/scalar/string/regexp.cpp

@@ -146,7 +146,7 @@ unique_ptr<FunctionData> RegexpReplaceBindData::Copy() const {
 }
 
 bool RegexpReplaceBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (const RegexpReplaceBindData &)other_p;
+	auto &other = other_p.Cast<RegexpReplaceBindData>();
 	return RegexpBaseBindData::Equals(other) && global_replace == other.global_replace;
 }
 
@@ -214,7 +214,7 @@ unique_ptr<FunctionData> RegexpExtractBindData::Copy() const {
 }
 
 bool RegexpExtractBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (const RegexpExtractBindData &)other_p;
+	auto &other = other_p.Cast<RegexpExtractBindData>();
 	return RegexpBaseBindData::Equals(other) && group_string == other.group_string;
 }
 
@@ -286,7 +286,7 @@ static void RegexExtractStructFunction(DataChunk &args, ExpressionState &state,
 		input.ToUnifiedFormat(count, iunified);
 
 		const auto &ivalidity = iunified.validity;
-		auto idata = (const string_t *)iunified.data;
+		auto idata = UnifiedVectorFormat::GetData<string_t>(iunified);
 
 		// Start with a valid flat vector
 		result.SetVectorType(VectorType::FLAT_VECTOR);

package/src/duckdb/src/function/scalar/string/strip_accents.cpp

@@ -23,7 +23,7 @@ struct StripAccentsOperator {
 
 		// non-ascii, perform collation
 		auto stripped = utf8proc_remove_accents((const utf8proc_uint8_t *)input.GetData(), input.GetSize());
-		auto result_str = StringVector::AddString(result, (const char *)stripped);
+		auto result_str = StringVector::AddString(result, const_char_ptr_cast(stripped));
 		free(stripped);
 		return result_str;
 	}

package/src/duckdb/src/function/scalar/struct/struct_extract.cpp

@@ -21,7 +21,7 @@ public:
 		return make_uniq<StructExtractBindData>(key, index, type);
 	}
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const StructExtractBindData &)other_p;
+		auto &other = other_p.Cast<StructExtractBindData>();
 		return key == other.key && index == other.index && type == other.type;
 	}
 };

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -23,7 +23,7 @@ struct ExportAggregateBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const ExportAggregateBindData &)other_p;
+		auto &other = other_p.Cast<ExportAggregateBindData>();
 		return aggr == other.aggr && state_size == other.state_size;
 	}
 
@@ -42,14 +42,14 @@ struct CombineState : public FunctionLocalState {
 	explicit CombineState(idx_t state_size_p)
 	    : state_size(state_size_p), state_buffer0(make_unsafe_uniq_array<data_t>(state_size_p)),
 	      state_buffer1(make_unsafe_uniq_array<data_t>(state_size_p)),
-	      state_vector0(Value::POINTER((uintptr_t)state_buffer0.get())),
-	      state_vector1(Value::POINTER((uintptr_t)state_buffer1.get())) {
+	      state_vector0(Value::POINTER(CastPointerToValue(state_buffer0.get()))),
+	      state_vector1(Value::POINTER(CastPointerToValue(state_buffer1.get()))) {
 	}
 };
 
 static unique_ptr<FunctionLocalState> InitCombineState(ExpressionState &state, const BoundFunctionExpression &expr,
                                                        FunctionData *bind_data_p) {
-	auto &bind_data = *(ExportAggregateBindData *)bind_data_p;
+	auto &bind_data = bind_data_p->Cast<ExportAggregateBindData>();
 	return make_uniq<CombineState>(bind_data.state_size);
 }
 
@@ -67,13 +67,13 @@ struct FinalizeState : public FunctionLocalState {
 
 static unique_ptr<FunctionLocalState> InitFinalizeState(ExpressionState &state, const BoundFunctionExpression &expr,
                                                         FunctionData *bind_data_p) {
-	auto &bind_data = *(ExportAggregateBindData *)bind_data_p;
+	auto &bind_data = bind_data_p->Cast<ExportAggregateBindData>();
 	return make_uniq<FinalizeState>(bind_data.state_size);
 }
 
 static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, Vector &result) {
 	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
-	auto &local_state = (FinalizeState &)*((ExecuteFunctionState &)state_p).local_state;
+	auto &local_state = ExecuteFunctionState::GetFunctionState(state_p)->Cast<FinalizeState>();
 
 	D_ASSERT(bind_data.state_size == bind_data.aggr.state_size());
 	D_ASSERT(input.data.size() == 1);
@@ -86,8 +86,8 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 	input.data[0].ToUnifiedFormat(input.size(), state_data);
 	for (idx_t i = 0; i < input.size(); i++) {
 		auto state_idx = state_data.sel->get_index(i);
-		auto state_entry = &((string_t *)state_data.data)[state_idx];
-		auto target_ptr = (const char *)local_state.state_buffer.get() + aligned_state_size * i;
+		auto state_entry = UnifiedVectorFormat::GetData<string_t>(state_data) + state_idx;
+		auto target_ptr = char_ptr_cast(local_state.state_buffer.get()) + aligned_state_size * i;
 
 		if (state_data.validity.RowIsValid(state_idx)) {
 			D_ASSERT(state_entry->GetSize() == bind_data.state_size);
@@ -95,9 +95,9 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 		} else {
 			// create a dummy state because finalize does not understand NULLs in its input
 			// we put the NULL back in explicitly below
-			bind_data.aggr.initialize((data_ptr_t)target_ptr);
+			bind_data.aggr.initialize(data_ptr_cast(target_ptr));
 		}
-		state_vec_ptr[i] = (data_ptr_t)target_ptr;
+		state_vec_ptr[i] = data_ptr_cast(target_ptr);
 	}
 
 	AggregateInputData aggr_input_data(nullptr, Allocator::DefaultAllocator());
@@ -113,7 +113,7 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 
 static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Vector &result) {
 	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
-	auto &local_state = (CombineState &)*((ExecuteFunctionState &)state_p).local_state;
+	auto &local_state = ExecuteFunctionState::GetFunctionState(state_p)->Cast<CombineState>();
 
 	D_ASSERT(bind_data.state_size == bind_data.aggr.state_size());
 
@@ -136,8 +136,8 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 		auto state0_idx = state0_data.sel->get_index(i);
 		auto state1_idx = state1_data.sel->get_index(i);
 
-		auto &state0 = ((string_t *)state0_data.data)[state0_idx];
-		auto &state1 = ((string_t *)state1_data.data)[state1_idx];
+		auto &state0 = UnifiedVectorFormat::GetData<string_t>(state0_data)[state0_idx];
+		auto &state1 = UnifiedVectorFormat::GetData<string_t>(state1_data)[state1_idx];
 
 		// if both are NULL, we return NULL. If either of them is not, the result is that one
 		if (!state0_data.validity.RowIsValid(state0_idx) && !state1_data.validity.RowIsValid(state1_idx)) {
@@ -145,11 +145,13 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 			continue;
 		}
 		if (state0_data.validity.RowIsValid(state0_idx) && !state1_data.validity.RowIsValid(state1_idx)) {
-			result_ptr[i] = StringVector::AddStringOrBlob(result, (const char *)state0.GetData(), bind_data.state_size);
+			result_ptr[i] =
+			    StringVector::AddStringOrBlob(result, const_char_ptr_cast(state0.GetData()), bind_data.state_size);
 			continue;
 		}
 		if (!state0_data.validity.RowIsValid(state0_idx) && state1_data.validity.RowIsValid(state1_idx)) {
-			result_ptr[i] = StringVector::AddStringOrBlob(result, (const char *)state1.GetData(), bind_data.state_size);
+			result_ptr[i] =
+			    StringVector::AddStringOrBlob(result, const_char_ptr_cast(state1.GetData()), bind_data.state_size);
 			continue;
 		}
 
@@ -165,8 +167,8 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 		AggregateInputData aggr_input_data(nullptr, Allocator::DefaultAllocator());
 		bind_data.aggr.combine(local_state.state_vector0, local_state.state_vector1, aggr_input_data, 1);
 
-		result_ptr[i] =
-		    StringVector::AddStringOrBlob(result, (const char *)local_state.state_buffer1.get(), bind_data.state_size);
+		result_ptr[i] = StringVector::AddStringOrBlob(result, const_char_ptr_cast(local_state.state_buffer1.get()),
+		                                              bind_data.state_size);
 	}
 }
 
@@ -244,19 +246,19 @@ static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, Scala
 static void ExportAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
                                     idx_t offset) {
 	D_ASSERT(offset == 0);
-	auto bind_data = (ExportAggregateFunctionBindData *)aggr_input_data.bind_data;
-	auto state_size = bind_data->aggregate->function.state_size();
+	auto &bind_data = aggr_input_data.bind_data->Cast<ExportAggregateFunctionBindData>();
+	auto state_size = bind_data.aggregate->function.state_size();
 	auto blob_ptr = FlatVector::GetData<string_t>(result);
 	auto addresses_ptr = FlatVector::GetData<data_ptr_t>(state);
 	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
 		auto data_ptr = addresses_ptr[row_idx];
-		blob_ptr[row_idx] = StringVector::AddStringOrBlob(result, (const char *)data_ptr, state_size);
+		blob_ptr[row_idx] = StringVector::AddStringOrBlob(result, const_char_ptr_cast(data_ptr), state_size);
 	}
 }
 
 ExportAggregateFunctionBindData::ExportAggregateFunctionBindData(unique_ptr<Expression> aggregate_p) {
 	D_ASSERT(aggregate_p->type == ExpressionType::BOUND_AGGREGATE);
-	aggregate = unique_ptr<BoundAggregateExpression>((BoundAggregateExpression *)aggregate_p.release());
+	aggregate = unique_ptr_cast<Expression, BoundAggregateExpression>(std::move(aggregate_p));
 }
 
 unique_ptr<FunctionData> ExportAggregateFunctionBindData::Copy() const {
@@ -264,8 +266,8 @@ unique_ptr<FunctionData> ExportAggregateFunctionBindData::Copy() const {
 }
 
 bool ExportAggregateFunctionBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (const ExportAggregateFunctionBindData &)other_p;
-	return aggregate->Equals(other.aggregate.get());
+	auto &other = other_p.Cast<ExportAggregateFunctionBindData>();
+	return aggregate->Equals(*other.aggregate);
 }
 
 static void ExportStateAggregateSerialize(FieldWriter &writer, const FunctionData *bind_data_p,