duckdb 0.7.2-dev2320.0 → 0.7.2-dev2366.0

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

@@ -20,7 +20,7 @@ idx_t Bit::ComputeBitstringLen(idx_t len) {
 }
 
 static inline idx_t GetBitPadding(const string_t &bit_string) {
-	auto data = (const_data_ptr_t)bit_string.GetDataUnsafe();
+	auto data = (const_data_ptr_t)bit_string.GetData();
 	D_ASSERT(idx_t(data[0]) <= 8);
 	return data[0];
 }
@@ -46,7 +46,7 @@ void Bit::Finalize(string_t &str) {
 
 void Bit::SetEmptyBitString(string_t &target, string_t &input) {
 	char *res_buf = target.GetDataWriteable();
-	const char *buf = input.GetDataUnsafe();
+	const char *buf = input.GetData();
 	memset(res_buf, 0, input.GetSize());
 	res_buf[0] = buf[0];
 	Bit::Finalize(target);
@@ -61,7 +61,7 @@ void Bit::SetEmptyBitString(string_t &target, idx_t len) {
 
 // **** casting functions ****
 void Bit::ToString(string_t bits, char *output) {
-	auto data = (const_data_ptr_t)bits.GetDataUnsafe();
+	auto data = (const_data_ptr_t)bits.GetData();
 	auto len = bits.GetSize();
 
 	idx_t padding = GetBitPadding(bits);
@@ -84,7 +84,7 @@ string Bit::ToString(string_t str) {
 }
 
 bool Bit::TryGetBitStringSize(string_t str, idx_t &str_len, string *error_message) {
-	auto data = (const_data_ptr_t)str.GetDataUnsafe();
+	auto data = (const_data_ptr_t)str.GetData();
 	auto len = str.GetSize();
 	str_len = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -107,7 +107,7 @@ bool Bit::TryGetBitStringSize(string_t str, idx_t &str_len, string *error_messag
 }
 
 void Bit::ToBit(string_t str, string_t &output_str) {
-	auto data = (const_data_ptr_t)str.GetDataUnsafe();
+	auto data = (const_data_ptr_t)str.GetData();
 	auto len = str.GetSize();
 	auto output = output_str.GetDataWriteable();
 
@@ -149,7 +149,7 @@ string Bit::ToBit(string_t str) {
 // **** scalar functions ****
 void Bit::BitString(const string_t &input, const idx_t &bit_length, string_t &result) {
 	char *res_buf = result.GetDataWriteable();
-	const char *buf = input.GetDataUnsafe();
+	const char *buf = input.GetData();
 
 	auto padding = ComputePadding(bit_length);
 	res_buf[0] = padding;
@@ -174,7 +174,7 @@ idx_t Bit::OctetLength(string_t bits) {
 
 idx_t Bit::BitCount(string_t bits) {
 	idx_t count = 0;
-	const char *buf = bits.GetDataUnsafe();
+	const char *buf = bits.GetData();
 	for (idx_t byte_idx = 1; byte_idx < OctetLength(bits) + 1; byte_idx++) {
 		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
 			count += (buf[byte_idx] & (1 << bit_idx)) ? 1 : 0;
@@ -184,7 +184,7 @@ idx_t Bit::BitCount(string_t bits) {
 }
 
 idx_t Bit::BitPosition(string_t substring, string_t bits) {
-	const char *buf = bits.GetDataUnsafe();
+	const char *buf = bits.GetData();
 	auto len = bits.GetSize();
 	auto substr_len = BitLength(substring);
 	idx_t substr_idx = 0;
@@ -226,7 +226,7 @@ idx_t Bit::GetBitIndex(idx_t n) {
 }
 
 idx_t Bit::GetBitInternal(string_t bit_string, idx_t n) {
-	const char *buf = bit_string.GetDataUnsafe();
+	const char *buf = bit_string.GetData();
 	auto idx = Bit::GetBitIndex(n);
 	D_ASSERT(idx < bit_string.GetSize());
 	char byte = buf[idx] >> (7 - (n % 8));
@@ -254,7 +254,7 @@ void Bit::SetBitInternal(string_t &bit_string, idx_t n, idx_t new_value) {
 // **** BITWISE operators ****
 void Bit::RightShift(const string_t &bit_string, const idx_t &shift, string_t &result) {
 	char *res_buf = result.GetDataWriteable();
-	const char *buf = bit_string.GetDataUnsafe();
+	const char *buf = bit_string.GetData();
 	res_buf[0] = buf[0];
 	for (idx_t i = 0; i < Bit::BitLength(result); i++) {
 		if (i < shift) {
@@ -269,7 +269,7 @@ void Bit::RightShift(const string_t &bit_string, const idx_t &shift, string_t &r
 
 void Bit::LeftShift(const string_t &bit_string, const idx_t &shift, string_t &result) {
 	char *res_buf = result.GetDataWriteable();
-	const char *buf = bit_string.GetDataUnsafe();
+	const char *buf = bit_string.GetData();
 	res_buf[0] = buf[0];
 	for (idx_t i = 0; i < Bit::BitLength(bit_string); i++) {
 		if (i < (Bit::BitLength(bit_string) - shift)) {
@@ -289,8 +289,8 @@ void Bit::BitwiseAnd(const string_t &rhs, const string_t &lhs, string_t &result)
 	}
 
 	char *buf = result.GetDataWriteable();
-	const char *r_buf = rhs.GetDataUnsafe();
-	const char *l_buf = lhs.GetDataUnsafe();
+	const char *r_buf = rhs.GetData();
+	const char *l_buf = lhs.GetData();
 
 	buf[0] = l_buf[0];
 	for (idx_t i = 1; i < lhs.GetSize(); i++) {
@@ -306,8 +306,8 @@ void Bit::BitwiseOr(const string_t &rhs, const string_t &lhs, string_t &result)
 	}
 
 	char *buf = result.GetDataWriteable();
-	const char *r_buf = rhs.GetDataUnsafe();
-	const char *l_buf = lhs.GetDataUnsafe();
+	const char *r_buf = rhs.GetData();
+	const char *l_buf = lhs.GetData();
 
 	buf[0] = l_buf[0];
 	for (idx_t i = 1; i < lhs.GetSize(); i++) {
@@ -323,8 +323,8 @@ void Bit::BitwiseXor(const string_t &rhs, const string_t &lhs, string_t &result)
 	}
 
 	char *buf = result.GetDataWriteable();
-	const char *r_buf = rhs.GetDataUnsafe();
-	const char *l_buf = lhs.GetDataUnsafe();
+	const char *r_buf = rhs.GetData();
+	const char *l_buf = lhs.GetData();
 
 	buf[0] = l_buf[0];
 	for (idx_t i = 1; i < lhs.GetSize(); i++) {
@@ -335,7 +335,7 @@ void Bit::BitwiseXor(const string_t &rhs, const string_t &lhs, string_t &result)
 
 void Bit::BitwiseNot(const string_t &input, string_t &result) {
 	char *result_buf = result.GetDataWriteable();
-	const char *buf = input.GetDataUnsafe();
+	const char *buf = input.GetData();
 
 	result_buf[0] = buf[0];
 	for (idx_t i = 1; i < input.GetSize(); i++) {

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

@@ -24,7 +24,7 @@ bool IsRegularCharacter(data_t c) {
 }
 
 idx_t Blob::GetStringSize(string_t blob) {
-	auto data = (const_data_ptr_t)blob.GetDataUnsafe();
+	auto data = (const_data_ptr_t)blob.GetData();
 	auto len = blob.GetSize();
 	idx_t str_len = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -40,7 +40,7 @@ idx_t Blob::GetStringSize(string_t blob) {
 }
 
 void Blob::ToString(string_t blob, char *output) {
-	auto data = (const_data_ptr_t)blob.GetDataUnsafe();
+	auto data = (const_data_ptr_t)blob.GetData();
 	auto len = blob.GetSize();
 	idx_t str_idx = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -70,7 +70,7 @@ string Blob::ToString(string_t blob) {
 }
 
 bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) {
-	auto data = (const_data_ptr_t)str.GetDataUnsafe();
+	auto data = (const_data_ptr_t)str.GetData();
 	auto len = str.GetSize();
 	str_len = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -112,7 +112,7 @@ idx_t Blob::GetBlobSize(string_t str) {
 }
 
 void Blob::ToBlob(string_t str, data_ptr_t output) {
-	auto data = (const_data_ptr_t)str.GetDataUnsafe();
+	auto data = (const_data_ptr_t)str.GetData();
 	auto len = str.GetSize();
 	idx_t blob_idx = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -149,7 +149,7 @@ idx_t Blob::ToBase64Size(string_t blob) {
 }
 
 void Blob::ToBase64(string_t blob, char *output) {
-	auto input_data = (const_data_ptr_t)blob.GetDataUnsafe();
+	auto input_data = (const_data_ptr_t)blob.GetData();
 	auto input_size = blob.GetSize();
 	idx_t out_idx = 0;
 	idx_t i;
@@ -192,7 +192,7 @@ static constexpr int BASE64_DECODING_TABLE[256] = {
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
 
 idx_t Blob::FromBase64Size(string_t str) {
-	auto input_data = str.GetDataUnsafe();
+	auto input_data = str.GetData();
 	auto input_size = str.GetSize();
 	if (input_size % 4 != 0) {
 		// valid base64 needs to always be cleanly divisible by 4
@@ -239,7 +239,7 @@ uint32_t DecodeBase64Bytes(const string_t &str, const_data_ptr_t input_data, idx
 
 void Blob::FromBase64(string_t str, data_ptr_t output, idx_t output_size) {
 	D_ASSERT(output_size == FromBase64Size(str));
-	auto input_data = (const_data_ptr_t)str.GetDataUnsafe();
+	auto input_data = (const_data_ptr_t)str.GetData();
 	auto input_size = str.GetSize();
 	if (input_size == 0) {
 		return;

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

@@ -197,7 +197,7 @@ void ColumnDataAllocator::UnswizzlePointers(ChunkManagementState &state, Vector
 	D_ASSERT(i < end);
 
 	auto base_ptr = (char *)GetDataPointer(state, block_id, offset);
-	if (strings[i].GetDataUnsafe() == base_ptr) {
+	if (strings[i].GetData() == base_ptr) {
 		// pointers are still valid
 		return;
 	}

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

@@ -519,7 +519,7 @@ void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVector
 				target_entry = source_entry;
 			} else {
 				D_ASSERT(heap_ptr != nullptr);
-				memcpy(heap_ptr, source_entry.GetDataUnsafe(), source_entry.GetSize());
+				memcpy(heap_ptr, source_entry.GetData(), source_entry.GetSize());
 				target_entry = string_t((const char *)heap_ptr, source_entry.GetSize());
 				heap_ptr += source_entry.GetSize();
 			}

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

@@ -64,7 +64,7 @@ hash_t Hash(const char *str) {
 
 template <>
 hash_t Hash(string_t val) {
-	return Hash(val.GetDataUnsafe(), val.GetSize());
+	return Hash(val.GetData(), val.GetSize());
 }
 
 template <>

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

@@ -169,7 +169,7 @@ inline uint64_t HashOtherSize(const data_ptr_t &data, const idx_t &len) {
 
 template <>
 inline uint64_t TemplatedHash(const string_t &elem) {
-	data_ptr_t data = (data_ptr_t)elem.GetDataUnsafe();
+	data_ptr_t data = (data_ptr_t)elem.GetData();
 	const auto &len = elem.GetSize();
 	uint64_t h = 0;
 	for (idx_t i = 0; i + sizeof(uint64_t) <= len; i += sizeof(uint64_t)) {

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

@@ -28,7 +28,7 @@ inline void TupleDataValueStore(const string_t &source, const data_ptr_t &row_lo
 	if (source.IsInlined()) {
 		Store<string_t>(source, row_location + offset_in_row);
 	} else {
-		memcpy(heap_location, source.GetDataUnsafe(), source.GetSize());
+		memcpy(heap_location, source.GetData(), source.GetSize());
 		Store<string_t>(string_t((const char *)heap_location, source.GetSize()), row_location + offset_in_row);
 		heap_location += source.GetSize();
 	}
@@ -44,7 +44,7 @@ template <>
 inline void TupleDataWithinListValueStore(const string_t &source, const data_ptr_t &location,
                                           data_ptr_t &heap_location) {
 	Store<uint32_t>(source.GetSize(), location);
-	memcpy(heap_location, source.GetDataUnsafe(), source.GetSize());
+	memcpy(heap_location, source.GetData(), source.GetSize());
 	heap_location += source.GetSize();
 }
 

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

@@ -34,7 +34,7 @@ string_t StringHeap::AddString(const string &data) {
 }
 
 string_t StringHeap::AddString(const string_t &data) {
-	return AddString(data.GetDataUnsafe(), data.GetSize());
+	return AddString(data.GetData(), data.GetSize());
 }
 
 string_t StringHeap::AddBlob(const char *data, idx_t len) {
@@ -46,7 +46,7 @@ string_t StringHeap::AddBlob(const char *data, idx_t len) {
 }
 
 string_t StringHeap::AddBlob(const string_t &data) {
-	return AddBlob(data.GetDataUnsafe(), data.GetSize());
+	return AddBlob(data.GetData(), data.GetSize());
 }
 
 string_t StringHeap::EmptyString(idx_t len) {

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

@@ -7,7 +7,7 @@
 namespace duckdb {
 
 void string_t::Verify() const {
-	auto dataptr = GetDataUnsafe();
+	auto dataptr = GetData();
 	(void)dataptr;
 	D_ASSERT(dataptr);
 
@@ -22,7 +22,7 @@ void string_t::Verify() const {
 	}
 	// verify that for strings with length <= INLINE_LENGTH, the rest of the string is zero
 	for (idx_t i = GetSize(); i < INLINE_LENGTH; i++) {
-		D_ASSERT(GetDataUnsafe()[i] == '\0');
+		D_ASSERT(GetData()[i] == '\0');
 	}
 }
 

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

@@ -102,7 +102,7 @@ TimestampCastResult Timestamp::TryConvertTimestamp(const char *str, idx_t len, t
 	}
 	if (tz.GetSize() == 3) {
 		// we can ONLY handle UTC without ICU being loaded
-		auto tz_ptr = tz.GetDataUnsafe();
+		auto tz_ptr = tz.GetData();
 		if ((tz_ptr[0] == 'u' || tz_ptr[0] == 'U') && (tz_ptr[1] == 't' || tz_ptr[1] == 'T') &&
 		    (tz_ptr[2] == 'c' || tz_ptr[2] == 'C')) {
 			return TimestampCastResult::SUCCESS;

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

@@ -456,7 +456,7 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) {
 		auto str_compressed = ((string_t *)data)[index];
 		Value result =
 		    FSSTPrimitives::DecompressValue(FSSTVector::GetDecoder(const_cast<Vector &>(*vector)),
-		                                    (unsigned char *)str_compressed.GetDataUnsafe(), str_compressed.GetSize());
+		                                    (unsigned char *)str_compressed.GetData(), str_compressed.GetSize());
 		return result;
 	}
 
@@ -543,11 +543,11 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) {
 	case LogicalTypeId::AGGREGATE_STATE:
 	case LogicalTypeId::BLOB: {
 		auto str = ((string_t *)data)[index];
-		return Value::BLOB((const_data_ptr_t)str.GetDataUnsafe(), str.GetSize());
+		return Value::BLOB((const_data_ptr_t)str.GetData(), str.GetSize());
 	}
 	case LogicalTypeId::BIT: {
 		auto str = ((string_t *)data)[index];
-		return Value::BIT((const_data_ptr_t)str.GetDataUnsafe(), str.GetSize());
+		return Value::BIT((const_data_ptr_t)str.GetData(), str.GetSize());
 	}
 	case LogicalTypeId::MAP: {
 		auto offlen = ((list_entry_t *)data)[index];
@@ -637,7 +637,7 @@ string Vector::ToString(idx_t count) const {
 		for (idx_t i = 0; i < count; i++) {
 			string_t compressed_string = ((string_t *)data)[i];
 			Value val = FSSTPrimitives::DecompressValue(FSSTVector::GetDecoder(const_cast<Vector &>(*this)),
-			                                            (unsigned char *)compressed_string.GetDataUnsafe(),
+			                                            (unsigned char *)compressed_string.GetData(),
 			                                            compressed_string.GetSize());
 			retval += GetValue(i).ToString() + (i == count - 1 ? "" : ", ");
 		}
@@ -924,7 +924,7 @@ void Vector::Serialize(idx_t count, Serializer &serializer) {
 			for (idx_t i = 0; i < count; i++) {
 				auto idx = vdata.sel->get_index(i);
 				auto source = !vdata.validity.RowIsValid(idx) ? NullValue<string_t>() : strings[idx];
-				serializer.WriteStringLen((const_data_ptr_t)source.GetDataUnsafe(), source.GetSize());
+				serializer.WriteStringLen((const_data_ptr_t)source.GetData(), source.GetSize());
 			}
 			break;
 		}
@@ -1321,7 +1321,7 @@ void Vector::Verify(Vector &vector_p, const SelectionVector &sel_p, idx_t count)
 			for (idx_t i = 0; i < count; i++) {
 				auto oidx = sel->get_index(i);
 				if (validity.RowIsValid(oidx)) {
-					auto buf = strings[oidx].GetDataUnsafe();
+					auto buf = strings[oidx].GetData();
 					D_ASSERT(*buf >= 0 && *buf < 8);
 					Bit::Verify(strings[oidx]);
 				}
@@ -1706,7 +1706,7 @@ void FSSTVector::DecompressVector(const Vector &src, Vector &dst, idx_t src_offs
 		string_t compressed_string = ldata[source_idx];
 		if (dst_mask.RowIsValid(target_idx) && compressed_string.GetSize() > 0) {
 			tdata[target_idx] = FSSTPrimitives::DecompressValue(FSSTVector::GetDecoder(src), dst,
-			                                                    (unsigned char *)compressed_string.GetDataUnsafe(),
+			                                                    (unsigned char *)compressed_string.GetData(),
 			                                                    compressed_string.GetSize());
 		} else {
 			tdata[target_idx] = string_t(nullptr, 0);

package/src/duckdb/src/execution/index/art/art_key.cpp

@@ -18,7 +18,7 @@ template <>
 Key Key::CreateKey(ArenaAllocator &allocator, const LogicalType &type, string_t value) {
 	idx_t len = value.GetSize() + 1;
 	auto data = allocator.Allocate(len);
-	memcpy(data, value.GetDataUnsafe(), len - 1);
+	memcpy(data, value.GetData(), len - 1);
 
 	// FIXME: rethink this
 	if (type == LogicalType::BLOB || type == LogicalType::VARCHAR) {
@@ -43,7 +43,7 @@ template <>
 void Key::CreateKey(ArenaAllocator &allocator, const LogicalType &type, Key &key, string_t value) {
 	key.len = value.GetSize() + 1;
 	key.data = allocator.Allocate(key.len);
-	memcpy(key.data, value.GetDataUnsafe(), key.len - 1);
+	memcpy(key.data, value.GetData(), key.len - 1);
 
 	// FIXME: rethink this
 	if (type == LogicalType::BLOB || type == LogicalType::VARCHAR) {

package/src/duckdb/src/execution/operator/persistent/base_csv_reader.cpp

@@ -381,7 +381,7 @@ void BaseCSVReader::VerifyUTF8(idx_t col_idx, idx_t row_idx, DataChunk &chunk, i
 
 	auto parse_data = FlatVector::GetData<string_t>(chunk.data[col_idx]);
 	auto s = parse_data[row_idx];
-	auto utf_type = Utf8Proc::Analyze(s.GetDataUnsafe(), s.GetSize());
+	auto utf_type = Utf8Proc::Analyze(s.GetData(), s.GetSize());
 	if (utf_type == UnicodeType::INVALID) {
 		string col_name = to_string(col_idx);
 		if (col_idx < names.size()) {

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