duckdb 0.7.2-dev2320.0 → 0.7.2-dev2410.0

package/src/duckdb/src/execution/operator/schema/physical_create_type.cpp

@@ -52,7 +52,7 @@ SinkResultType PhysicalCreateType::Sink(ExecutionContext &context, GlobalSinkSta
 			throw InvalidInputException("Attempted to create ENUM type with NULL value!");
 		}
 		result_ptr[gstate.size++] =
-		    StringVector::AddStringOrBlob(gstate.result, src_ptr[idx].GetDataUnsafe(), src_ptr[idx].GetSize());
+		    StringVector::AddStringOrBlob(gstate.result, src_ptr[idx].GetData(), src_ptr[idx].GetSize());
 	}
 	return SinkResultType::NEED_MORE_INPUT;
 }

package/src/duckdb/src/execution/physical_plan/plan_asof_join.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/execution/operator/aggregate/physical_window.hpp"
+#include "duckdb/execution/operator/join/physical_asof_join.hpp"
 #include "duckdb/execution/operator/join/physical_iejoin.hpp"
 #include "duckdb/execution/operator/projection/physical_projection.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
@@ -39,7 +40,11 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAsOfJoin &
 	}
 	D_ASSERT(asof_idx < op.conditions.size());
 
-	//	Temporary implementation: IEJoin of Window
+	if (!ClientConfig::GetConfig(context).force_asof_iejoin) {
+		return make_uniq<PhysicalAsOfJoin>(op, std::move(left), std::move(right));
+	}
+
+	//	Debug implementation: IEJoin of Window
 	//	LEAD(asof_column, 1, infinity) OVER (PARTITION BY equi_column... ORDER BY asof_column) AS asof_temp
 	auto &asof_comp = op.conditions[asof_idx];
 	auto &asof_column = asof_comp.right;
@@ -47,6 +52,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAsOfJoin &
 	auto asof_temp = make_uniq<BoundWindowExpression>(ExpressionType::WINDOW_LEAD, asof_type, nullptr, nullptr);
 	asof_temp->children.emplace_back(asof_column->Copy());
 	asof_temp->offset_expr = make_uniq<BoundConstantExpression>(Value::BIGINT(1));
+	// TODO: If infinities are not supported for a type, fake them by looking at LHS statistics?
 	asof_temp->default_expr = make_uniq<BoundConstantExpression>(Value::Infinity(asof_type));
 	for (auto equi_idx : equi_indexes) {
 		asof_temp->partitions.emplace_back(op.conditions[equi_idx].right->Copy());

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

@@ -41,7 +41,7 @@ void ArgMinMaxStateBase::CreateValue(Vector *&value) {
 template <>
 void ArgMinMaxStateBase::DestroyValue(string_t &value) {
 	if (!value.IsInlined()) {
-		delete[] value.GetDataUnsafe();
+		delete[] value.GetData();
 	}
 }
 
@@ -62,7 +62,7 @@ void ArgMinMaxStateBase::AssignValue(string_t &target, string_t new_value, bool
 		// non-inlined string, need to allocate space for it
 		auto len = new_value.GetSize();
 		auto ptr = new char[len];
-		memcpy(ptr, new_value.GetDataUnsafe(), len);
+		memcpy(ptr, new_value.GetData(), len);
 
 		target = string_t(ptr, len);
 	}

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

@@ -130,7 +130,7 @@ struct BitStringBitwiseOperation : public BitwiseOperation {
 	template <class STATE>
 	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
 		if (state->is_set && !state->value.IsInlined()) {
-			delete[] state->value.GetDataUnsafe();
+			delete[] state->value.GetData();
 		}
 	}
 
@@ -142,7 +142,7 @@ struct BitStringBitwiseOperation : public BitwiseOperation {
 		} else { // non-inlined string, need to allocate space for it
 			auto len = input.GetSize();
 			auto ptr = new char[len];
-			memcpy(ptr, input.GetDataUnsafe(), len);
+			memcpy(ptr, input.GetData(), len);
 
 			state->value = string_t(ptr, len);
 		}

package/src/duckdb/src/function/aggregate/distributive/bitstring_agg.cpp

@@ -134,7 +134,7 @@ struct BitStringAggOperation {
 		} else { // non-inlined string, need to allocate space for it
 			auto len = input.GetSize();
 			auto ptr = new char[len];
-			memcpy(ptr, input.GetDataUnsafe(), len);
+			memcpy(ptr, input.GetData(), len);
 			state->value = string_t(ptr, len);
 		}
 	}
@@ -151,7 +151,7 @@ struct BitStringAggOperation {
 	template <class STATE>
 	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
 		if (state->is_set && !state->value.IsInlined()) {
-			delete[] state->value.GetDataUnsafe();
+			delete[] state->value.GetData();
 		}
 	}
 

package/src/duckdb/src/function/aggregate/distributive/first.cpp

@@ -86,7 +86,7 @@ struct FirstFunctionString : public FirstFunctionBase {
 				// non-inlined string, need to allocate space for it
 				auto len = value.GetSize();
 				auto ptr = new char[len];
-				memcpy(ptr, value.GetDataUnsafe(), len);
+				memcpy(ptr, value.GetData(), len);
 
 				state->value = string_t(ptr, len);
 			}
@@ -126,7 +126,7 @@ struct FirstFunctionString : public FirstFunctionBase {
 	template <class STATE>
 	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
 		if (state->is_set && !state->is_null && !state->value.IsInlined()) {
-			delete[] state->value.GetDataUnsafe();
+			delete[] state->value.GetData();
 		}
 	}
 };

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

@@ -70,9 +70,10 @@ struct KurtosisOperation {
 		            6 * state->sum_sqr * state->sum * state->sum * temp * temp - 3 * pow(state->sum, 4) * pow(temp, 3));
 
 		double m2 = temp * (state->sum_sqr - state->sum * state->sum * temp);
-		if (((m2 * m2) - 3 * (n - 1)) == 0 || ((n - 2) * (n - 3)) == 0) { // LCOV_EXCL_START
+		if (m2 <= 0 || ((n - 2) * (n - 3)) == 0) { // m2 shouldn't be below 0 but floating points are weird
 			mask.SetInvalid(idx);
-		} // LCOV_EXCL_STOP
+			return;
+		}
 		target[idx] = (n - 1) * ((n + 1) * m4 / (m2 * m2) - 3 * (n - 1)) / ((n - 2) * (n - 3));
 		if (!Value::DoubleIsFinite(target[idx])) {
 			throw OutOfRangeException("Kurtosis is out of range!");

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

@@ -144,7 +144,7 @@ struct StringMinMaxBase : public MinMaxBase {
 	template <class STATE>
 	static void Destroy(AggregateInputData &aggr_input_data, STATE *state) {
 		if (state->isset && !state->value.IsInlined()) {
-			delete[] state->value.GetDataUnsafe();
+			delete[] state->value.GetData();
 		}
 	}
 
@@ -157,7 +157,7 @@ struct StringMinMaxBase : public MinMaxBase {
 			// non-inlined string, need to allocate space for it
 			auto len = input.GetSize();
 			auto ptr = new char[len];
-			memcpy(ptr, input.GetDataUnsafe(), len);
+			memcpy(ptr, input.GetData(), len);
 
 			state->value = string_t(ptr, len);
 		}

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

@@ -56,7 +56,11 @@ struct SkewnessOperation {
 		}
 		double n = state->n;
 		double temp = 1 / n;
-		double div = (std::sqrt(std::pow(temp * (state->sum_sqr - state->sum * state->sum * temp), 3)));
+		auto p = std::pow(temp * (state->sum_sqr - state->sum * state->sum * temp), 3);
+		if (p < 0) {
+			p = 0; // Shouldn't be below 0 but floating points are weird
+		}
+		double div = std::sqrt(p);
 		if (div == 0) {
 			mask.SetInvalid(idx);
 			return;

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

@@ -90,7 +90,7 @@ struct StringAggFunction {
 
 	static inline void PerformOperation(StringAggState *state, string_t str, FunctionData *data_p) {
 		auto &data = data_p->Cast<StringAggBindData>();
-		PerformOperation(state, str.GetDataUnsafe(), data.sep.c_str(), str.GetSize(), data.sep.size());
+		PerformOperation(state, str.GetData(), data.sep.c_str(), str.GetSize(), data.sep.size());
 	}
 
 	template <class INPUT_TYPE, class STATE, class OP>

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

@@ -106,7 +106,7 @@ static bool ListToVarcharCast(Vector &source, Vector &result, idx_t count, CastP
 			}
 			if (child_validity.RowIsValid(idx)) {
 				auto len = child_data[idx].GetSize();
-				memcpy(dataptr + offset, child_data[idx].GetDataUnsafe(), len);
+				memcpy(dataptr + offset, child_data[idx].GetData(), len);
 				offset += len;
 			} else {
 				memcpy(dataptr + offset, "NULL", NULL_LENGTH);

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

@@ -118,7 +118,7 @@ static bool StructToVarcharCast(Vector &source, Vector &result, idx_t count, Cas
 			// value
 			if (child_validity.RowIsValid(i)) {
 				auto len = data[i].GetSize();
-				memcpy(dataptr + offset, data[i].GetDataUnsafe(), len);
+				memcpy(dataptr + offset, data[i].GetData(), len);
 				offset += len;
 			} else {
 				memcpy(dataptr + offset, "NULL", NULL_LENGTH);

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

@@ -105,7 +105,7 @@ struct SplitStringListOperation {
 
 template <class OP>
 static bool SplitStringListInternal(const string_t &input, OP &state) {
-	const char *buf = input.GetDataUnsafe();
+	const char *buf = input.GetData();
 	idx_t len = input.GetSize();
 	idx_t lvl = 1;
 	idx_t pos = 0;
@@ -221,7 +221,7 @@ static bool FindKeyOrValueMap(const char *buf, idx_t len, idx_t &pos, OP &state,
 
 template <class OP>
 static bool SplitStringMapInternal(const string_t &input, OP &state) {
-	const char *buf = input.GetDataUnsafe();
+	const char *buf = input.GetData();
 	idx_t len = input.GetSize();
 	idx_t pos = 0;
 
@@ -301,7 +301,7 @@ static bool FindValueStruct(const char *buf, idx_t len, idx_t &pos, Vector &varc
 
 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) {
-	const char *buf = input.GetDataUnsafe();
+	const char *buf = input.GetData();
 	idx_t len = input.GetSize();
 	idx_t pos = 0;
 	idx_t child_idx;

package/src/duckdb/src/function/scalar/bit/bitstring.cpp

@@ -68,7 +68,7 @@ static void SetBitOperation(DataChunk &args, ExpressionState &state, Vector &res
 			                              NumericHelper::ToString(Bit::BitLength(input) - 1));
 		    }
 		    string_t target = StringVector::EmptyString(result, input.GetSize());
-		    memcpy(target.GetDataWriteable(), input.GetDataUnsafe(), input.GetSize());
+		    memcpy(target.GetDataWriteable(), input.GetData(), input.GetSize());
 		    Bit::SetBit(target, n, new_value);
 		    return target;
 	    });

package/src/duckdb/src/function/scalar/blob/encode.cpp

@@ -12,7 +12,7 @@ static void EncodeFunction(DataChunk &args, ExpressionState &state, Vector &resu
 struct BlobDecodeOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = input.GetData();
 		auto input_length = input.GetSize();
 		if (Utf8Proc::Analyze(input_data, input_length) == UnicodeType::INVALID) {
 			throw ConversionException(

package/src/duckdb/src/function/scalar/date/strftime.cpp

@@ -154,7 +154,7 @@ idx_t StrfTimeFormat::GetLength(date_t date, dtime_t time, int32_t utc_offset, c
 
 char *StrfTimeFormat::WriteString(char *target, const string_t &str) {
 	idx_t size = str.GetSize();
-	memcpy(target, str.GetDataUnsafe(), size);
+	memcpy(target, str.GetData(), size);
 	return target + size;
 }
 
@@ -766,7 +766,7 @@ int32_t StrpTimeFormat::TryParseCollection(const char *data, idx_t &pos, idx_t s
                                            idx_t collection_count) {
 	for (idx_t c = 0; c < collection_count; c++) {
 		auto &entry = collection[c];
-		auto entry_data = entry.GetDataUnsafe();
+		auto entry_data = entry.GetData();
 		auto entry_size = entry.GetSize();
 		// check if this entry matches
 		if (pos + entry_size > size) {
@@ -805,7 +805,7 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) {
 	result_data[6] = 0;
 	result_data[7] = 0;
 
-	auto data = str.GetDataUnsafe();
+	auto data = str.GetData();
 	idx_t size = str.GetSize();
 	// skip leading spaces
 	while (StringUtil::CharacterIsSpace(*data)) {

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

@@ -41,7 +41,7 @@ unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFuncti
 	    key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
 		throw ParserException("Key name for current_setting needs to be a constant string");
 	}
-	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child.get());
+	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child);
 	D_ASSERT(key_val.type().id() == LogicalTypeId::VARCHAR);
 	auto &key_str = StringValue::Get(key_val);
 	if (key_val.IsNull() || key_str.empty()) {

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

@@ -244,83 +244,57 @@ static unique_ptr<FunctionData> ListSortBind(ClientContext &context, ScalarFunct
 	return make_uniq<ListSortBindData>(order, null_order, bound_function.return_type, child_type, context);
 }
 
-static OrderByNullType GetNullOrder(ClientContext &context, vector<unique_ptr<Expression>> &arguments, idx_t idx) {
-
-	if (!arguments[idx]->IsFoldable()) {
-		throw InvalidInputException("Null sorting order must be a constant");
-	}
-	Value null_order_value = ExpressionExecutor::EvaluateScalar(context, *arguments[idx]);
-	auto null_order_name = StringUtil::Upper(null_order_value.ToString());
-	const auto null_order_arg = EnumSerializer::StringToEnum<OrderByNullType>(null_order_name.c_str());
-	switch (null_order_arg) {
-	case OrderByNullType::NULLS_FIRST:
-	case OrderByNullType::NULLS_LAST:
-		return null_order_arg;
-	case OrderByNullType::ORDER_DEFAULT:
-		return DBConfig::GetConfig(context).options.default_null_order;
-	default:
-		throw InvalidInputException("Null sorting order must be either NULLS FIRST, NULLS LAST or DEFAULT");
+template <class T>
+static T GetOrder(ClientContext &context, Expression &expr) {
+	if (!expr.IsFoldable()) {
+		throw InvalidInputException("Sorting order must be a constant");
 	}
+	Value order_value = ExpressionExecutor::EvaluateScalar(context, expr);
+	auto order_name = StringUtil::Upper(order_value.ToString());
+	return EnumSerializer::StringToEnum<T>(order_name.c_str());
 }
 
 static unique_ptr<FunctionData> ListNormalSortBind(ClientContext &context, ScalarFunction &bound_function,
                                                    vector<unique_ptr<Expression>> &arguments) {
-
-	D_ASSERT(!bound_function.arguments.empty() && bound_function.arguments.size() <= 3);
 	D_ASSERT(!arguments.empty() && arguments.size() <= 3);
-
-	// set default values
-	auto &config = DBConfig::GetConfig(context);
-	auto order = config.options.default_order_type;
-	auto null_order = config.options.default_null_order;
+	auto order = OrderType::ORDER_DEFAULT;
+	auto null_order = OrderByNullType::ORDER_DEFAULT;
 
 	// get the sorting order
 	if (arguments.size() >= 2) {
-
-		if (!arguments[1]->IsFoldable()) {
-			throw InvalidInputException("Sorting order must be a constant");
-		}
-		Value order_value = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-
-		const auto order_name = StringUtil::Upper(order_value.ToString());
-		const auto order_arg = EnumSerializer::StringToEnum<OrderType>(order_name.c_str());
-		switch (order_arg) {
-		case OrderType::ASCENDING:
-		case OrderType::DESCENDING:
-			order = order_arg;
-			break;
-		case OrderType::ORDER_DEFAULT:
-			break;
-		default:
-			throw InvalidInputException("Sorting order must be either ASC, DESC or DEFAULT");
-		}
+		order = GetOrder<OrderType>(context, *arguments[1]);
 	}
-
 	// get the null sorting order
 	if (arguments.size() == 3) {
-		null_order = GetNullOrder(context, arguments, 2);
+		null_order = GetOrder<OrderByNullType>(context, *arguments[2]);
 	}
-
+	auto &config = DBConfig::GetConfig(context);
+	order = config.ResolveOrder(order);
+	null_order = config.ResolveNullOrder(order, null_order);
 	return ListSortBind(context, bound_function, arguments, order, null_order);
 }
 
 static unique_ptr<FunctionData> ListReverseSortBind(ClientContext &context, ScalarFunction &bound_function,
                                                     vector<unique_ptr<Expression>> &arguments) {
+	auto order = OrderType::ORDER_DEFAULT;
+	auto null_order = OrderByNullType::ORDER_DEFAULT;
 
-	D_ASSERT(bound_function.arguments.size() == 1 || bound_function.arguments.size() == 2);
-	D_ASSERT(arguments.size() == 1 || arguments.size() == 2);
-
-	// set (reverse) default values
-	auto &config = DBConfig::GetConfig(context);
-	auto order =
-	    (config.options.default_order_type == OrderType::ASCENDING) ? OrderType::DESCENDING : OrderType::ASCENDING;
-	auto null_order = config.options.default_null_order;
-
-	// get the null sorting order
 	if (arguments.size() == 2) {
-		null_order = GetNullOrder(context, arguments, 1);
+		null_order = GetOrder<OrderByNullType>(context, *arguments[1]);
 	}
-
+	auto &config = DBConfig::GetConfig(context);
+	order = config.ResolveOrder(order);
+	switch (order) {
+	case OrderType::ASCENDING:
+		order = OrderType::DESCENDING;
+		break;
+	case OrderType::DESCENDING:
+		order = OrderType::ASCENDING;
+		break;
+	default:
+		throw InternalException("Unexpected order type in list reverse sort");
+	}
+	null_order = config.ResolveNullOrder(order, null_order);
 	return ListSortBind(context, bound_function, arguments, order, null_order);
 }
 

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

@@ -7,7 +7,7 @@ namespace duckdb {
 struct AsciiOperator {
 	template <class TA, class TR>
 	static inline TR Operation(const TA &input) {
-		auto str = input.GetDataUnsafe();
+		auto str = input.GetData();
 		if (Utf8Proc::Analyze(str, input.GetSize()) == UnicodeType::ASCII) {
 			return str[0];
 		}

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

@@ -120,7 +120,7 @@ template <bool IS_UPPER>
 struct CaseConvertOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = input.GetData();
 		auto input_length = input.GetSize();
 		return UnicodeCaseConvert<IS_UPPER>(result, input_data, input_length);
 	}
@@ -135,7 +135,7 @@ template <bool IS_UPPER>
 struct CaseConvertOperatorASCII {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = input.GetData();
 		auto input_length = input.GetSize();
 		return ASCIICaseConvert<IS_UPPER>(result, input_data, input_length);
 	}

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

@@ -66,7 +66,7 @@ static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &resu
 			}
 			// append the constant vector to each of the strings
 			auto input_data = ConstantVector::GetData<string_t>(input);
-			auto input_ptr = input_data->GetDataUnsafe();
+			auto input_ptr = input_data->GetData();
 			auto input_len = input_data->GetSize();
 			for (idx_t i = 0; i < args.size(); i++) {
 				memcpy(result_data[i].GetDataWriteable() + result_lengths[i], input_ptr, input_len);
@@ -83,7 +83,7 @@ static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &resu
 				if (!idata.validity.RowIsValid(idx)) {
 					continue;
 				}
-				auto input_ptr = input_data[idx].GetDataUnsafe();
+				auto input_ptr = input_data[idx].GetData();
 				auto input_len = input_data[idx].GetSize();
 				memcpy(result_data[i].GetDataWriteable() + result_lengths[i], input_ptr, input_len);
 				result_lengths[i] += input_len;
@@ -98,8 +98,8 @@ static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &resu
 static void ConcatOperator(DataChunk &args, ExpressionState &state, Vector &result) {
 	BinaryExecutor::Execute<string_t, string_t, string_t>(
 	    args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b) {
-		    auto a_data = a.GetDataUnsafe();
-		    auto b_data = b.GetDataUnsafe();
+		    auto a_data = a.GetData();
+		    auto b_data = b.GetData();
 		    auto a_length = a.GetSize();
 		    auto b_length = b.GetSize();
 
@@ -167,11 +167,11 @@ static void TemplatedConcatWS(DataChunk &args, string_t *sep_data, const Selecti
 			}
 			if (has_results[ridx]) {
 				auto sep_size = sep_data[sep_idx].GetSize();
-				auto sep_ptr = sep_data[sep_idx].GetDataUnsafe();
+				auto sep_ptr = sep_data[sep_idx].GetData();
 				memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], sep_ptr, sep_size);
 				result_lengths[ridx] += sep_size;
 			}
-			auto input_ptr = input_data[idx].GetDataUnsafe();
+			auto input_ptr = input_data[idx].GetData();
 			auto input_len = input_data[idx].GetSize();
 			memcpy(result_data[ridx].GetDataWriteable() + result_lengths[ridx], input_ptr, input_len);
 			result_lengths[ridx] += input_len;

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

@@ -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.GetDataUnsafe();
+	auto haystack = (const unsigned char *)haystack_s.GetData();
 	auto haystack_size = haystack_s.GetSize();
-	auto needle = (const unsigned char *)needle_s.GetDataUnsafe();
+	auto needle = (const unsigned char *)needle_s.GetData();
 	auto needle_size = needle_s.GetSize();
 	if (needle_size == 0) {
 		// empty needle: always true

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

@@ -25,8 +25,8 @@ static idx_t DamerauLevenshteinDistance(const string_t &source, const string_t &
 		return source_len * COST_DELETION;
 	}
 
-	const auto source_str = source.GetDataUnsafe();
-	const auto target_str = target.GetDataUnsafe();
+	const auto source_str = source.GetData();
+	const auto target_str = target.GetData();
 
 	// larger than the largest possible value:
 	const auto inf = source_len * COST_DELETION + target_len * COST_INSERTION + 1;

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

@@ -63,7 +63,7 @@ static void WriteHugeIntBinBytes(hugeint_t x, char *&output, idx_t buffer_size)
 struct HexStrOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto data = input.GetDataUnsafe();
+		auto data = input.GetData();
 		auto size = input.GetSize();
 
 		// Allocate empty space
@@ -150,7 +150,7 @@ static void ToHexFunction(DataChunk &args, ExpressionState &state, Vector &resul
 struct BinaryStrOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto data = input.GetDataUnsafe();
+		auto data = input.GetData();
 		auto size = input.GetSize();
 
 		// Allocate empty space
@@ -228,7 +228,7 @@ struct BinaryHugeIntOperator {
 struct FromHexOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto data = input.GetDataUnsafe();
+		auto data = input.GetData();
 		auto size = input.GetSize();
 
 		if (size > NumericLimits<uint32_t>::Maximum()) {
@@ -265,7 +265,7 @@ struct FromHexOperator {
 struct FromBinaryOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		auto data = input.GetDataUnsafe();
+		auto data = input.GetData();
 		auto size = input.GetSize();
 
 		if (size > NumericLimits<uint32_t>::Maximum()) {

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

@@ -16,7 +16,7 @@ struct InstrOperator {
 		auto location = ContainsFun::Find(haystack, needle);
 		if (location != DConstants::INVALID_INDEX) {
 			auto len = (utf8proc_ssize_t)location;
-			auto str = reinterpret_cast<const utf8proc_uint8_t *>(haystack.GetDataUnsafe());
+			auto str = reinterpret_cast<const utf8proc_uint8_t *>(haystack.GetData());
 			D_ASSERT(len <= (utf8proc_ssize_t)haystack.GetSize());
 			for (++string_position; len > 0; ++string_position) {
 				utf8proc_int32_t codepoint;

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

@@ -9,7 +9,7 @@ namespace duckdb {
 static inline map<char, idx_t> GetSet(const string_t &str) {
 	auto map_of_chars = map<char, idx_t> {};
 	idx_t str_len = str.GetSize();
-	auto s = str.GetDataUnsafe();
+	auto s = str.GetData();
 
 	for (idx_t pos = 0; pos < str_len; pos++) {
 		map_of_chars.insert(std::make_pair(s[pos], 1));

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

@@ -5,14 +5,14 @@
 namespace duckdb {
 
 static inline double JaroScalarFunction(const string_t &s1, const string_t &s2) {
-	auto s1_begin = s1.GetDataUnsafe();
-	auto s2_begin = s2.GetDataUnsafe();
+	auto s1_begin = s1.GetData();
+	auto s2_begin = s2.GetData();
 	return duckdb_jaro_winkler::jaro_similarity(s1_begin, s1_begin + s1.GetSize(), s2_begin, s2_begin + s2.GetSize());
 }
 
 static inline double JaroWinklerScalarFunction(const string_t &s1, const string_t &s2) {
-	auto s1_begin = s1.GetDataUnsafe();
-	auto s2_begin = s2.GetDataUnsafe();
+	auto s1_begin = s1.GetData();
+	auto s2_begin = s2.GetData();
 	return duckdb_jaro_winkler::jaro_winkler_similarity(s1_begin, s1_begin + s1.GetSize(), s2_begin,
 	                                                    s2_begin + s2.GetSize());
 }
@@ -29,7 +29,7 @@ static void CachedFunction(Vector &constant, Vector &other, Vector &result, idx_
 	auto str_val = StringValue::Get(val);
 	auto cached = CACHED_SIMILARITY(str_val);
 	UnaryExecutor::Execute<string_t, double>(other, result, count, [&](const string_t &other_str) {
-		auto other_str_begin = other_str.GetDataUnsafe();
+		auto other_str_begin = other_str.GetData();
 		return cached.similarity(other_str_begin, other_str_begin + other_str.GetSize());
 	});
 }

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

@@ -141,7 +141,7 @@ void LengthFun::RegisterFunction(BuiltinFunctions &set) {
 struct UnicodeOperator {
 	template <class TA, class TR>
 	static inline TR Operation(const TA &input) {
-		auto str = reinterpret_cast<const utf8proc_uint8_t *>(input.GetDataUnsafe());
+		auto str = reinterpret_cast<const utf8proc_uint8_t *>(input.GetData());
 		auto len = input.GetSize();
 		utf8proc_int32_t codepoint;
 		(void)utf8proc_iterate(str, len, &codepoint);

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

@@ -23,8 +23,8 @@ static idx_t LevenshteinDistance(const string_t &txt, const string_t &tgt) {
 		return txt_len;
 	}
 
-	auto txt_str = txt.GetDataUnsafe();
-	auto tgt_str = tgt.GetDataUnsafe();
+	auto txt_str = txt.GetData();
+	auto tgt_str = tgt.GetData();
 
 	// Create two working vectors
 	vector<idx_t> distances0(tgt_len + 1, 0);