duckdb 0.7.2-dev2320.0 → 0.7.2-dev2366.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);

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.GetDataUnsafe();
+		auto str_data = (const unsigned char *)str.GetData();
 		auto str_len = str.GetSize();
 		idx_t segment_idx = 0;
 		idx_t end_idx = segments.size() - 1;
@@ -213,11 +213,11 @@ bool LikeOperatorFunction(const char *s, idx_t slen, const char *pattern, idx_t
 }
 
 bool LikeOperatorFunction(string_t &s, string_t &pat) {
-	return LikeOperatorFunction(s.GetDataUnsafe(), s.GetSize(), pat.GetDataUnsafe(), pat.GetSize());
+	return LikeOperatorFunction(s.GetData(), s.GetSize(), pat.GetData(), pat.GetSize());
 }
 
 bool LikeOperatorFunction(string_t &s, string_t &pat, char escape) {
-	return LikeOperatorFunction(s.GetDataUnsafe(), s.GetSize(), pat.GetDataUnsafe(), pat.GetSize(), escape);
+	return LikeOperatorFunction(s.GetData(), s.GetSize(), pat.GetData(), pat.GetSize(), escape);
 }
 
 bool LikeFun::Glob(const char *string, idx_t slen, const char *pattern, idx_t plen, bool allow_question_mark) {
@@ -362,15 +362,14 @@ static char GetEscapeChar(string_t escape) {
 	if (escape.GetSize() > 1) {
 		throw SyntaxException("Invalid escape string. Escape string must be empty or one character.");
 	}
-	return escape.GetSize() == 0 ? '\0' : *escape.GetDataUnsafe();
+	return escape.GetSize() == 0 ? '\0' : *escape.GetData();
 }
 
 struct LikeEscapeOperator {
 	template <class TA, class TB, class TC>
 	static inline bool Operation(TA str, TB pattern, TC escape) {
 		char escape_char = GetEscapeChar(escape);
-		return LikeOperatorFunction(str.GetDataUnsafe(), str.GetSize(), pattern.GetDataUnsafe(), pattern.GetSize(),
-		                            escape_char);
+		return LikeOperatorFunction(str.GetData(), str.GetSize(), pattern.GetData(), pattern.GetSize(), escape_char);
 	}
 };
 
@@ -389,9 +388,9 @@ struct LikeOperator {
 };
 
 bool ILikeOperatorFunction(string_t &str, string_t &pattern, char escape = '\0') {
-	auto str_data = str.GetDataUnsafe();
+	auto str_data = str.GetData();
 	auto str_size = str.GetSize();
-	auto pat_data = pattern.GetDataUnsafe();
+	auto pat_data = pattern.GetData();
 	auto pat_size = pattern.GetSize();
 
 	// lowercase both the str and the pattern
@@ -446,8 +445,8 @@ struct NotILikeOperator {
 struct ILikeOperatorASCII {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA str, TB pattern) {
-		return TemplatedLikeOperator<'%', '_', false, ASCIILCaseReader>(
-		    str.GetDataUnsafe(), str.GetSize(), pattern.GetDataUnsafe(), pattern.GetSize(), '\0');
+		return TemplatedLikeOperator<'%', '_', false, ASCIILCaseReader>(str.GetData(), str.GetSize(), pattern.GetData(),
+		                                                                pattern.GetSize(), '\0');
 	}
 };
 
@@ -461,7 +460,7 @@ struct NotILikeOperatorASCII {
 struct GlobOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA str, TB pattern) {
-		return LikeFun::Glob(str.GetDataUnsafe(), str.GetSize(), pattern.GetDataUnsafe(), pattern.GetSize());
+		return LikeFun::Glob(str.GetData(), str.GetSize(), pattern.GetData(), pattern.GetSize());
 	}
 };
 

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

@@ -18,8 +18,8 @@ static int64_t MismatchesScalarFunction(Vector &result, const string_t str, stri
 	}
 
 	idx_t mismatches = 0;
-	auto str_str = str.GetDataUnsafe();
-	auto tgt_str = tgt.GetDataUnsafe();
+	auto str_str = str.GetData();
+	auto tgt_str = tgt.GetData();
 
 	for (idx_t idx = 0; idx < str_len; ++idx) {
 		if (str_str[idx] != tgt_str[idx]) {

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

@@ -7,7 +7,7 @@ namespace duckdb {
 struct NFCNormalizeOperator {
 	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();
 		if (StripAccentsFun::IsAscii(input_data, input_length)) {
 			return input;

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

@@ -27,7 +27,7 @@ static pair<idx_t, idx_t> PadCountChars(const idx_t len, const char *data, const
 
 static bool InsertPadding(const idx_t len, const string_t &pad, vector<char> &result) {
 	//  Copy the padding until the output is long enough
-	auto data = pad.GetDataUnsafe();
+	auto data = pad.GetData();
 	auto size = pad.GetSize();
 
 	//  Check whether we need data that we don't have
@@ -63,7 +63,7 @@ static string_t LeftPadFunction(const string_t &str, const int32_t len, const st
 	result.clear();
 
 	// Get information about the base string
-	auto data_str = str.GetDataUnsafe();
+	auto data_str = str.GetData();
 	auto size_str = str.GetSize();
 
 	//  Count how much of str will fit in the output
@@ -92,7 +92,7 @@ static string_t RightPadFunction(const string_t &str, const int32_t len, const s
 	result.clear();
 
 	// Get information about the base string
-	auto data_str = str.GetDataUnsafe();
+	auto data_str = str.GetData();
 	auto size_str = str.GetSize();
 
 	// Count how much of str will fit in the output

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

@@ -46,8 +46,8 @@ static bool PrefixFunction(const string_t &str, const string_t &pattern) {
 			}
 		}
 		// compare the rest of the prefix
-		const char *str_data = str.GetDataUnsafe();
-		const char *patt_data = pattern.GetDataUnsafe();
+		const char *str_data = str.GetData();
+		const char *patt_data = pattern.GetData();
 		D_ASSERT(patt_length <= str_length);
 		for (idx_t i = string_t::PREFIX_LENGTH; i < patt_length; ++i) {
 			if (str_data[i] != patt_data[i]) {

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

@@ -138,7 +138,7 @@ static void PrintfFunction(DataChunk &args, ExpressionState &state, Vector &resu
 			case LogicalTypeId::VARCHAR: {
 				auto arg_data = FlatVector::GetData<string_t>(col);
 				auto string_view =
-				    duckdb_fmt::basic_string_view<char>(arg_data[arg_idx].GetDataUnsafe(), arg_data[arg_idx].GetSize());
+				    duckdb_fmt::basic_string_view<char>(arg_data[arg_idx].GetData(), arg_data[arg_idx].GetSize());
 				format_args.emplace_back(duckdb_fmt::internal::make_arg<CTX>(string_view));
 				break;
 			}

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

@@ -86,7 +86,7 @@ void ExtractSingleTuple(const string_t &string, duckdb_re2::RE2 &pattern, int32_
 		idx_t child_idx = current_list_size;
 		if (match_group.empty()) {
 			// This group was not matched
-			list_content[child_idx] = string_t(string.GetDataUnsafe(), 0);
+			list_content[child_idx] = string_t(string.GetData(), 0);
 			if (match_group.begin() == nullptr) {
 				// This group is optional
 				child_validity.SetInvalid(child_idx);
@@ -94,9 +94,9 @@ 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.GetDataUnsafe());
-			idx_t offset = match_group.begin() - string.GetDataUnsafe();
-			list_content[child_idx] = string_t(string.GetDataUnsafe() + offset, match_group.size());
+			D_ASSERT((const char *)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());
 		}
 		current_list_size++;
 		if (startpos > input.size()) {

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

@@ -10,7 +10,7 @@ namespace duckdb {
 
 static string_t RepeatScalarFunction(const string_t &str, const int64_t cnt, vector<char> &result) {
 	// Get information about the repeated string
-	auto input_str = str.GetDataUnsafe();
+	auto input_str = str.GetData();
 	auto size_str = str.GetSize();
 
 	//  Reuse the buffer

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

@@ -29,13 +29,13 @@ static idx_t NextNeedle(const char *input_haystack, idx_t size_haystack, const c
 static string_t ReplaceScalarFunction(const string_t &haystack, const string_t &needle, const string_t &thread,
                                       vector<char> &result) {
 	// Get information about the needle, the haystack and the "thread"
-	auto input_haystack = haystack.GetDataUnsafe();
+	auto input_haystack = haystack.GetData();
 	auto size_haystack = haystack.GetSize();
 
-	auto input_needle = needle.GetDataUnsafe();
+	auto input_needle = needle.GetData();
 	auto size_needle = needle.GetSize();
 
-	auto input_thread = thread.GetDataUnsafe();
+	auto input_thread = thread.GetData();
 	auto size_thread = thread.GetSize();
 
 	//  Reuse the buffer

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

@@ -32,7 +32,7 @@ static void StrReverseUnicode(const char *input, idx_t n, char *output) {
 struct ReverseOperator {
 	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();
 
 		auto target = StringVector::EmptyString(result, input_length);

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

@@ -17,9 +17,9 @@ static bool StartsWith(const unsigned char *haystack, idx_t haystack_size, const
 }
 
 static bool StartsWith(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/string_split.cpp

@@ -68,9 +68,9 @@ struct RegexpStringSplit {
 struct StringSplitter {
 	template <class OP>
 	static idx_t Split(string_t input, string_t delim, StringSplitInput &state, void *data) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = input.GetData();
 		auto input_size = input.GetSize();
-		auto delim_data = delim.GetDataUnsafe();
+		auto delim_data = delim.GetData();
 		auto delim_size = delim.GetSize();
 		idx_t list_idx = 0;
 		while (input_size > 0) {
@@ -135,7 +135,7 @@ static void StringSplitExecutor(DataChunk &args, ExpressionState &state, Vector
 		StringSplitInput split_input(result, child_entry, total_splits);
 		if (!delim_data.validity.RowIsValid(delim_idx)) {
 			// delim is NULL: copy the complete entry
-			split_input.AddSplit(inputs[input_idx].GetDataUnsafe(), inputs[input_idx].GetSize(), 0);
+			split_input.AddSplit(inputs[input_idx].GetData(), inputs[input_idx].GetSize(), 0);
 			list_struct_data[i].length = 1;
 			list_struct_data[i].offset = total_splits;
 			total_splits++;

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

@@ -17,12 +17,12 @@ bool StripAccentsFun::IsAscii(const char *input, idx_t n) {
 struct StripAccentsOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, Vector &result) {
-		if (StripAccentsFun::IsAscii(input.GetDataUnsafe(), input.GetSize())) {
+		if (StripAccentsFun::IsAscii(input.GetData(), input.GetSize())) {
 			return input;
 		}
 
 		// non-ascii, perform collation
-		auto stripped = utf8proc_remove_accents((const utf8proc_uint8_t *)input.GetDataUnsafe(), input.GetSize());
+		auto stripped = utf8proc_remove_accents((const utf8proc_uint8_t *)input.GetData(), input.GetSize());
 		auto result_str = StringVector::AddString(result, (const char *)stripped);
 		free(stripped);
 		return result_str;

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

@@ -82,7 +82,7 @@ bool SubstringStartEnd(int64_t input_size, int64_t offset, int64_t length, int64
 }
 
 string_t SubstringASCII(Vector &result, string_t input, int64_t offset, int64_t length) {
-	auto input_data = input.GetDataUnsafe();
+	auto input_data = input.GetData();
 	auto input_size = input.GetSize();
 
 	AssertInSupportedRange(input_size, offset, length);
@@ -95,7 +95,7 @@ string_t SubstringASCII(Vector &result, string_t input, int64_t offset, int64_t
 }
 
 string_t SubstringFun::SubstringUnicode(Vector &result, string_t input, int64_t offset, int64_t length) {
-	auto input_data = input.GetDataUnsafe();
+	auto input_data = input.GetData();
 	auto input_size = input.GetSize();
 
 	AssertInSupportedRange(input_size, offset, length);
@@ -190,7 +190,7 @@ string_t SubstringFun::SubstringUnicode(Vector &result, string_t input, int64_t
 }
 
 string_t SubstringFun::SubstringGrapheme(Vector &result, string_t input, int64_t offset, int64_t length) {
-	auto input_data = input.GetDataUnsafe();
+	auto input_data = input.GetData();
 	auto input_size = input.GetSize();
 
 	AssertInSupportedRange(input_size, offset, length);

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

@@ -21,8 +21,8 @@ static bool SuffixFunction(const string_t &str, const string_t &suffix) {
 		return false;
 	}
 
-	auto suffix_data = suffix.GetDataUnsafe();
-	auto str_data = str.GetDataUnsafe();
+	auto suffix_data = suffix.GetData();
+	auto str_data = str.GetData();
 	int32_t suf_idx = suffix_size - 1;
 	idx_t str_idx = str_size - 1;
 	for (; suf_idx >= 0; --suf_idx, --str_idx) {

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

@@ -16,13 +16,13 @@ namespace duckdb {
 static string_t TranslateScalarFunction(const string_t &haystack, const string_t &needle, const string_t &thread,
                                         vector<char> &result) {
 	// Get information about the haystack, the needle and the "thread"
-	auto input_haystack = haystack.GetDataUnsafe();
+	auto input_haystack = haystack.GetData();
 	auto size_haystack = haystack.GetSize();
 
-	auto input_needle = needle.GetDataUnsafe();
+	auto input_needle = needle.GetData();
 	auto size_needle = needle.GetSize();
 
-	auto input_thread = thread.GetDataUnsafe();
+	auto input_thread = thread.GetData();
 	auto size_thread = thread.GetSize();
 
 	// Reuse the buffer

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

@@ -13,7 +13,7 @@ template <bool LTRIM, bool RTRIM>
 struct TrimOperator {
 	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();
 
 		utf8proc_int32_t codepoint;
@@ -64,7 +64,7 @@ static void UnaryTrimFunction(DataChunk &args, ExpressionState &state, Vector &r
 }
 
 static void GetIgnoredCodepoints(string_t ignored, unordered_set<utf8proc_int32_t> &ignored_codepoints) {
-	auto dataptr = (utf8proc_uint8_t *)ignored.GetDataUnsafe();
+	auto dataptr = (utf8proc_uint8_t *)ignored.GetData();
 	auto size = ignored.GetSize();
 	idx_t pos = 0;
 	while (pos < size) {
@@ -78,7 +78,7 @@ template <bool LTRIM, bool RTRIM>
 static void BinaryTrimFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	BinaryExecutor::Execute<string_t, string_t, string_t>(
 	    input.data[0], input.data[1], result, input.size(), [&](string_t input, string_t ignored) {
-		    auto data = input.GetDataUnsafe();
+		    auto data = input.GetData();
 		    auto size = input.GetSize();
 
 		    unordered_set<utf8proc_int32_t> ignored_codepoints;

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

@@ -62,7 +62,7 @@ static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, Scalar
 	if (key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
 		throw BinderException("Key name for struct_extract 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/system/aggregate_export.cpp

@@ -91,7 +91,7 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 
 		if (state_data.validity.RowIsValid(state_idx)) {
 			D_ASSERT(state_entry->GetSize() == bind_data.state_size);
-			memcpy((void *)target_ptr, state_entry->GetDataUnsafe(), bind_data.state_size);
+			memcpy((void *)target_ptr, state_entry->GetData(), bind_data.state_size);
 		} else {
 			// create a dummy state because finalize does not understand NULLs in its input
 			// we put the NULL back in explicitly below
@@ -145,13 +145,11 @@ 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.GetDataUnsafe(), bind_data.state_size);
+			result_ptr[i] = StringVector::AddStringOrBlob(result, (const char *)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.GetDataUnsafe(), bind_data.state_size);
+			result_ptr[i] = StringVector::AddStringOrBlob(result, (const char *)state1.GetData(), bind_data.state_size);
 			continue;
 		}
 
@@ -161,8 +159,8 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 			                  state0.GetSize(), state1.GetSize());
 		}
 
-		memcpy(local_state.state_buffer0.get(), state0.GetDataUnsafe(), bind_data.state_size);
-		memcpy(local_state.state_buffer1.get(), state1.GetDataUnsafe(), bind_data.state_size);
+		memcpy(local_state.state_buffer0.get(), state0.GetData(), bind_data.state_size);
+		memcpy(local_state.state_buffer1.get(), state1.GetData(), bind_data.state_size);
 
 		AggregateInputData aggr_input_data(nullptr, Allocator::DefaultAllocator());
 		bind_data.aggr.combine(local_state.state_vector0, local_state.state_vector1, aggr_input_data, 1);

package/src/duckdb/src/function/scalar/union/union_extract.cpp

@@ -60,7 +60,7 @@ static unique_ptr<FunctionData> UnionExtractBind(ClientContext &context, ScalarF
 	if (key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
 		throw BinderException("Key name for union_extract 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/table/copy_csv.cpp

@@ -357,7 +357,7 @@ static void WriteCSVSink(ExecutionContext &context, FunctionData &bind_data, Glo
 			// FIXME: we could gain some performance here by checking for certain types if they ever require quotes
 			// (e.g. integers only require quotes if the delimiter is a number, decimals only require quotes if the
 			// delimiter is a number or "." character)
-			WriteQuotedString(writer, csv_data, str_value.GetDataUnsafe(), str_value.GetSize(),
+			WriteQuotedString(writer, csv_data, str_value.GetData(), str_value.GetSize(),
 			                  csv_data.options.force_quote[col_idx]);
 		}
 		writer.WriteBufferData(csv_data.newline);

package/src/duckdb/src/function/table/system/duckdb_functions.cpp

@@ -239,7 +239,7 @@ struct MacroExtractor {
 
 	static Value GetMacroDefinition(ScalarMacroCatalogEntry &entry, idx_t offset) {
 		D_ASSERT(entry.function->type == MacroType::SCALAR_MACRO);
-		auto &func = (ScalarMacroFunction &)*entry.function;
+		auto &func = entry.function->Cast<ScalarMacroFunction>();
 		return func.expression->ToString();
 	}
 
@@ -295,7 +295,7 @@ struct TableMacroExtractor {
 
 	static Value GetMacroDefinition(TableMacroCatalogEntry &entry, idx_t offset) {
 		if (entry.function->type == MacroType::SCALAR_MACRO) {
-			auto &func = (ScalarMacroFunction &)*entry.function;
+			auto &func = entry.function->Cast<ScalarMacroFunction>();
 			return func.expression->ToString();
 		}
 		return Value();

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev2320"
+#define DUCKDB_VERSION "0.7.2-dev2366"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "04b7296af3"
+#define DUCKDB_SOURCE_ID "1d7b9c315e"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"