duckdb 0.8.1-dev31.0 → 0.8.1-dev341.0

package/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp

@@ -28,7 +28,7 @@ struct SortedAggregateBindData : public FunctionData {
 		}
 		sorted_on_args = (children.size() == order_bys.orders.size());
 		for (size_t i = 0; sorted_on_args && i < children.size(); ++i) {
-			sorted_on_args = children[i]->Equals(order_bys.orders[i].expression.get());
+			sorted_on_args = children[i]->Equals(*order_bys.orders[i].expression);
 		}
 	}
 
@@ -49,7 +49,7 @@ struct SortedAggregateBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const SortedAggregateBindData &)other_p;
+		auto &other = other_p.Cast<SortedAggregateBindData>();
 		if (bind_info && other.bind_info) {
 			if (!bind_info->Equals(*other.bind_info)) {
 				return false;
@@ -253,13 +253,13 @@ struct SortedAggregateState {
 
 struct SortedAggregateFunction {
 	template <typename STATE>
-	static void Initialize(STATE *state) {
-		new (state) STATE();
+	static void Initialize(STATE &state) {
+		new (&state) STATE();
 	}
 
 	template <typename STATE>
-	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
-		state->~STATE();
+	static void Destroy(STATE &state, AggregateInputData &aggr_input_data) {
+		state.~STATE();
 	}
 
 	static void ProjectInputs(Vector inputs[], const SortedAggregateBindData &order_bind, idx_t input_count,
@@ -288,7 +288,7 @@ struct SortedAggregateFunction {
 		DataChunk sort_chunk;
 		ProjectInputs(inputs, order_bind, input_count, count, arg_chunk, sort_chunk);
 
-		const auto order_state = (SortedAggregateState *)state;
+		const auto order_state = reinterpret_cast<SortedAggregateState *>(state);
 		order_state->Update(order_bind, sort_chunk, arg_chunk);
 	}
 
@@ -310,7 +310,7 @@ struct SortedAggregateFunction {
 		states.ToUnifiedFormat(count, svdata);
 
 		// Size the selection vector for each state.
-		auto sdata = (SortedAggregateState **)svdata.data;
+		auto sdata = UnifiedVectorFormat::GetDataNoConst<SortedAggregateState *>(svdata);
 		for (idx_t i = 0; i < count; ++i) {
 			auto sidx = svdata.sel->get_index(i);
 			auto order_state = sdata[sidx];
@@ -345,10 +345,10 @@ struct SortedAggregateFunction {
 	}
 
 	template <class STATE, class OP>
-	static void Combine(const STATE &source, STATE *target, AggregateInputData &aggr_input_data) {
-		const auto order_bind = (SortedAggregateBindData *)aggr_input_data.bind_data;
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &aggr_input_data) {
+		auto &order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
 		auto &other = const_cast<STATE &>(source);
-		target->Combine(*order_bind, other);
+		target.Combine(order_bind, other);
 	}
 
 	static void Window(Vector inputs[], const ValidityMask &filter_mask, AggregateInputData &aggr_input_data,
@@ -359,7 +359,7 @@ struct SortedAggregateFunction {
 
 	static void Finalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
 	                     const idx_t offset) {
-		const auto &order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
+		auto &order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
 		auto &buffer_manager = order_bind.buffer_manager;
 		RowLayout payload_layout;
 		payload_layout.Initialize(order_bind.arg_types);
@@ -370,7 +370,7 @@ struct SortedAggregateFunction {
 
 		//	 Reusable inner state
 		vector<data_t> agg_state(order_bind.function.state_size());
-		Vector agg_state_vec(Value::POINTER((idx_t)agg_state.data()));
+		Vector agg_state_vec(Value::POINTER(CastPointerToValue(agg_state.data())));
 
 		// State variables
 		auto bind_info = order_bind.bind_info.get();

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

@@ -158,7 +158,7 @@ int64_t CastFunctionSet::ImplicitCastCost(const LogicalType &source, const Logic
 
 BoundCastInfo MapCastFunction(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	D_ASSERT(input.info);
-	auto &map_info = (MapCastInfo &)*input.info;
+	auto &map_info = input.info->Cast<MapCastInfo>();
 	auto entry = map_info.GetEntry(source, target);
 	if (entry) {
 		if (entry->bind_function) {

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

@@ -207,7 +207,7 @@ struct DecimalCastInput {
 struct StringCastFromDecimalOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (DecimalCastInput *)dataptr;
+		auto data = reinterpret_cast<DecimalCastInput *>(dataptr);
 		return StringCastFromDecimal::Operation<INPUT_TYPE>(input, data->width, data->scale, data->result);
 	}
 };

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

@@ -17,7 +17,7 @@ bool EnumEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &p
 	UnifiedVectorFormat vdata;
 	source.ToUnifiedFormat(count, vdata);
 
-	auto source_data = (SRC_TYPE *)vdata.data;
+	auto source_data = UnifiedVectorFormat::GetData<SRC_TYPE>(vdata);
 	auto source_sel = vdata.sel;
 	auto source_mask = vdata.validity;
 
@@ -71,7 +71,7 @@ static bool EnumToVarcharCast(Vector &source, Vector &result, idx_t count, CastP
 	UnifiedVectorFormat vdata;
 	source.ToUnifiedFormat(count, vdata);
 
-	auto source_data = (SRC *)vdata.data;
+	auto source_data = UnifiedVectorFormat::GetData<SRC>(vdata);
 	for (idx_t i = 0; i < count; i++) {
 		auto source_idx = vdata.sel->get_index(i);
 		if (!vdata.validity.RowIsValid(source_idx)) {

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