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

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev2320.0",
+  "version": "0.7.2-dev2366.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/data_chunk.cpp

@@ -151,7 +151,7 @@ Napi::Array EncodeDataChunk(Napi::Env env, duckdb::DataChunk &chunk, bool with_t
 					auto data = duckdb::FlatVector::GetData<duckdb::string_t>(*vec);
 
 					for (size_t i = 0; i < chunk.size(); ++i) {
-						auto buf = Napi::Buffer<char>::Copy(env, data[i].GetDataUnsafe(), data[i].GetSize());
+						auto buf = Napi::Buffer<char>::Copy(env, data[i].GetData(), data[i].GetSize());
 						array.Set(i, buf);
 					}
 					desc.Set("data", array);

package/src/duckdb/extension/icu/icu-extension.cpp

@@ -69,7 +69,7 @@ struct IcuBindData : public FunctionData {
 static int32_t ICUGetSortKey(icu::Collator &collator, string_t input, duckdb::unique_ptr<char[]> &buffer,
                              int32_t &buffer_size) {
 	int32_t string_size =
-	    collator.getSortKey(icu::UnicodeString::fromUTF8(icu::StringPiece(input.GetDataUnsafe(), input.GetSize())),
+	    collator.getSortKey(icu::UnicodeString::fromUTF8(icu::StringPiece(input.GetData(), input.GetSize())),
 	                        (uint8_t *)buffer.get(), buffer_size);
 	if (string_size > buffer_size) {
 		// have to resize the buffer
@@ -77,7 +77,7 @@ static int32_t ICUGetSortKey(icu::Collator &collator, string_t input, duckdb::un
 		buffer = duckdb::unique_ptr<char[]>(new char[buffer_size]);
 
 		string_size =
-		    collator.getSortKey(icu::UnicodeString::fromUTF8(icu::StringPiece(input.GetDataUnsafe(), input.GetSize())),
+		    collator.getSortKey(icu::UnicodeString::fromUTF8(icu::StringPiece(input.GetData(), input.GetSize())),
 		                        (uint8_t *)buffer.get(), buffer_size);
 	}
 	return string_size;

package/src/duckdb/extension/icu/icu-makedate.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/vector_operations/senary_executor.hpp"
 #include "duckdb/common/vector_operations/septenary_executor.hpp"
+#include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "include/icu-datefunc.hpp"
 #include "include/icu-datetrunc.hpp"
@@ -11,6 +12,56 @@
 
 namespace duckdb {
 
+struct ICUMakeDate : public ICUDateFunc {
+	static inline date_t Operation(icu::Calendar *calendar, timestamp_t instant) {
+		if (!Timestamp::IsFinite(instant)) {
+			return Timestamp::GetDate(instant);
+		}
+
+		// Extract the time zone parts
+		auto micros = SetTime(calendar, instant);
+		const auto era = ExtractField(calendar, UCAL_ERA);
+		const auto year = ExtractField(calendar, UCAL_YEAR);
+		const auto mm = ExtractField(calendar, UCAL_MONTH) + 1;
+		const auto dd = ExtractField(calendar, UCAL_DATE);
+
+		const auto yyyy = era ? year : (-year + 1);
+		date_t result;
+		if (!Date::TryFromDate(yyyy, mm, dd, result)) {
+			throw ConversionException("Unable to convert TIMESTAMPTZ to DATE");
+		}
+
+		return result;
+	}
+
+	static bool CastToDate(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+		auto &cast_data = parameters.cast_data->Cast<CastData>();
+		auto info = (BindData *)cast_data.info.get();
+		CalendarPtr calendar(info->calendar->clone());
+
+		UnaryExecutor::Execute<timestamp_t, date_t>(
+		    source, result, count, [&](timestamp_t input) { return Operation(calendar.get(), input); });
+		return true;
+	}
+
+	static BoundCastInfo BindCastToDate(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
+		if (!input.context) {
+			throw InternalException("Missing context for TIMESTAMPTZ to DATE cast.");
+		}
+
+		auto cast_data = make_uniq<CastData>(make_uniq<BindData>(*input.context));
+
+		return BoundCastInfo(CastToDate, std::move(cast_data));
+	}
+
+	static void AddCasts(ClientContext &context) {
+		auto &config = DBConfig::GetConfig(context);
+		auto &casts = config.GetCastFunctions();
+
+		casts.RegisterCastFunction(LogicalType::TIMESTAMP_TZ, LogicalType::DATE, BindCastToDate);
+	}
+};
+
 struct ICUMakeTimestampTZFunc : public ICUDateFunc {
 	template <typename T>
 	static inline timestamp_t Operation(icu::Calendar *calendar, T yyyy, T mm, T dd, T hr, T mn, double ss) {
@@ -95,6 +146,7 @@ struct ICUMakeTimestampTZFunc : public ICUDateFunc {
 
 void RegisterICUMakeDateFunctions(ClientContext &context) {
 	ICUMakeTimestampTZFunc::AddFunction("make_timestamptz", context);
+	ICUMakeDate::AddCasts(context);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu-strptime.cpp

@@ -255,7 +255,7 @@ struct ICUStrptime : public ICUDateFunc {
 		UnaryExecutor::ExecuteWithNulls<string_t, timestamp_t>(
 		    source, result, count, [&](string_t input, ValidityMask &mask, idx_t idx) {
 			    timestamp_t result;
-			    const auto str = input.GetDataUnsafe();
+			    const auto str = input.GetData();
 			    const auto len = input.GetSize();
 			    string_t tz(nullptr, 0);
 			    bool has_offset = false;

package/src/duckdb/extension/icu/third_party/icu/i18n/calendar.cpp

@@ -2981,6 +2981,10 @@ void Calendar::computeTime(UErrorCode& status) {
 
     // Compute the Julian day
     int32_t julianDay = computeJulianDay();
+    if (julianDay < getMinimum(UCAL_JULIAN_DAY) || julianDay > getMaximum(UCAL_JULIAN_DAY)) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return;
+    }
 
     double millis = Grego::julianDayToMillis(julianDay);
 

package/src/duckdb/extension/icu/third_party/icu/i18n/dangical.cpp

@@ -56,7 +56,7 @@ DangiCalendar::DangiCalendar(const Locale& aLocale, UErrorCode& success)
 {
 }
 
-DangiCalendar::DangiCalendar (const DangiCalendar& other) 
+DangiCalendar::DangiCalendar (const DangiCalendar& other)
 : ChineseCalendar(other)
 {
 }
@@ -71,37 +71,37 @@ DangiCalendar::clone() const
     return new DangiCalendar(*this);
 }
 
-const char *DangiCalendar::getType() const { 
+const char *DangiCalendar::getType() const {
     return "dangi";
 }
 
 /**
  * The time zone used for performing astronomical computations for
- * Dangi calendar. In Korea various timezones have been used historically 
- * (cf. http://www.math.snu.ac.kr/~kye/others/lunar.html): 
- *  
- *            - 1908/04/01: GMT+8 
- * 1908/04/01 - 1911/12/31: GMT+8.5 
- * 1912/01/01 - 1954/03/20: GMT+9 
- * 1954/03/21 - 1961/08/09: GMT+8.5 
- * 1961/08/10 -           : GMT+9 
- *  
- * Note that, in 1908-1911, the government did not apply the timezone change 
- * but used GMT+8. In addition, 1954-1961's timezone change does not affect 
- * the lunar date calculation. Therefore, the following simpler rule works: 
- *   
- * -1911: GMT+8 
- * 1912-: GMT+9 
- *  
- * Unfortunately, our astronomer's approximation doesn't agree with the 
- * references (http://www.math.snu.ac.kr/~kye/others/lunar.html and 
- * http://astro.kasi.re.kr/Life/ConvertSolarLunarForm.aspx?MenuID=115) 
- * in 1897/7/30. So the following ad hoc fix is used here: 
- *  
- *     -1896: GMT+8 
- *      1897: GMT+7 
- * 1898-1911: GMT+8 
- * 1912-    : GMT+9 
+ * Dangi calendar. In Korea various timezones have been used historically
+ * (cf. http://www.math.snu.ac.kr/~kye/others/lunar.html):
+ *
+ *            - 1908/04/01: GMT+8
+ * 1908/04/01 - 1911/12/31: GMT+8.5
+ * 1912/01/01 - 1954/03/20: GMT+9
+ * 1954/03/21 - 1961/08/09: GMT+8.5
+ * 1961/08/10 -           : GMT+9
+ *
+ * Note that, in 1908-1911, the government did not apply the timezone change
+ * but used GMT+8. In addition, 1954-1961's timezone change does not affect
+ * the lunar date calculation. Therefore, the following simpler rule works:
+ *
+ * -1911: GMT+8
+ * 1912-: GMT+9
+ *
+ * Unfortunately, our astronomer's approximation doesn't agree with the
+ * references (http://www.math.snu.ac.kr/~kye/others/lunar.html and
+ * http://astro.kasi.re.kr/Life/ConvertSolarLunarForm.aspx?MenuID=115)
+ * in 1897/7/30. So the following ad hoc fix is used here:
+ *
+ *     -1896: GMT+8
+ *      1897: GMT+7
+ * 1898-1911: GMT+8
+ * 1912-    : GMT+9
  */
 static void U_CALLCONV initDangiCalZoneAstroCalc(void) {
     U_ASSERT(gDangiCalendarZoneAstroCalc == NULL);
@@ -127,7 +127,7 @@ static void U_CALLCONV initDangiCalZoneAstroCalc(void) {
     ucln_i18n_registerCleanup(UCLN_I18N_DANGI_CALENDAR, calendar_dangi_cleanup);
 }
 
-const TimeZone* DangiCalendar::getDangiCalZoneAstroCalc(void) const {
+TimeZone* DangiCalendar::getDangiCalZoneAstroCalc(void) {
     umtx_initOnce(gDangiCalendarInitOnce, &initDangiCalZoneAstroCalc);
     return gDangiCalendarZoneAstroCalc;
 }

package/src/duckdb/extension/icu/third_party/icu/i18n/dangical.h

@@ -27,7 +27,7 @@ U_NAMESPACE_BEGIN
  * <p><code>DangiCalendar</code> is a concrete subclass of {@link Calendar}
  * that implements a traditional Korean lunisolar calendar.</p>
  *
- * <p>DangiCalendar usually should be instantiated using 
+ * <p>DangiCalendar usually should be instantiated using
  * {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a <code>ULocale</code>
  * with the tag <code>"@calendar=dangi"</code>.</p>
  *
@@ -74,10 +74,10 @@ class DangiCalendar : public ChineseCalendar {
 
  private:
 
-  const TimeZone* getDangiCalZoneAstroCalc(void) const;
+  static TimeZone* getDangiCalZoneAstroCalc(void);
 
   // UObject stuff
- public: 
+ public:
   /**
    * @return   The class ID for this object. All objects of a given class have the
    *           same class ID. Objects of other classes have different class IDs.
@@ -108,7 +108,7 @@ class DangiCalendar : public ChineseCalendar {
 
 
  private:
- 
+
   DangiCalendar(); // default constructor not implemented
 };
 

package/src/duckdb/extension/json/include/json_common.hpp

@@ -228,7 +228,7 @@ public:
 	//! Get JSON value using JSON path query (safe, checks the path query)
 	template <class YYJSON_VAL_T>
 	static inline YYJSON_VAL_T *GetPointer(YYJSON_VAL_T *root, const string_t &path_str) {
-		auto ptr = path_str.GetDataUnsafe();
+		auto ptr = path_str.GetData();
 		auto len = path_str.GetSize();
 		if (len == 0) {
 			return GetPointerUnsafe<YYJSON_VAL_T>(root, ptr, len);

package/src/duckdb/extension/json/json_functions/json_create.cpp

@@ -185,7 +185,7 @@ inline yyjson_mut_val *CreateJSONValue(yyjson_mut_doc *doc, const double &value)
 
 template <>
 inline yyjson_mut_val *CreateJSONValue(yyjson_mut_doc *doc, const string_t &value) {
-	return yyjson_mut_strn(doc, value.GetDataUnsafe(), value.GetSize());
+	return yyjson_mut_strn(doc, value.GetData(), value.GetSize());
 }
 
 inline yyjson_mut_val *CreateJSONValueFromJSON(yyjson_mut_doc *doc, const string_t &value) {

package/src/duckdb/extension/json/json_functions/json_transform.cpp

@@ -98,7 +98,7 @@ static duckdb::unique_ptr<FunctionData> JSONTransformBind(ClientContext &context
 		auto doc = JSONCommon::ReadDocumentUnsafe(structure_string, JSONCommon::READ_FLAG,
 		                                          json_allocator.GetYYJSONAllocator(), &err);
 		if (err.code != YYJSON_READ_SUCCESS) {
-			JSONCommon::ThrowParseError(structure_string.GetDataUnsafe(), structure_string.GetSize(), err);
+			JSONCommon::ThrowParseError(structure_string.GetData(), structure_string.GetSize(), err);
 		}
 		bound_function.return_type = StructureStringToType(doc->root, context);
 	}

package/src/duckdb/extension/json/json_functions.cpp

@@ -19,7 +19,7 @@ static void CheckPath(const Value &path_val, string &path, size_t &len) {
 	}
 	auto path_str = path_str_val.GetValueUnsafe<string_t>();
 	len = path_str.GetSize();
-	auto ptr = path_str.GetDataUnsafe();
+	auto ptr = path_str.GetData();
 	// Empty strings and invalid $ paths yield an error
 	if (len == 0) {
 		throw InvalidInputException("Empty JSON path");
@@ -213,7 +213,7 @@ static bool CastVarcharToJSON(Vector &source, Vector &result, idx_t count, CastP
 	bool success = true;
 	UnaryExecutor::ExecuteWithNulls<string_t, string_t>(
 	    source, result, count, [&](string_t input, ValidityMask &mask, idx_t idx) {
-		    auto data = (char *)(input.GetDataUnsafe());
+		    auto data = (char *)(input.GetData());
 		    auto length = input.GetSize();
 		    yyjson_read_err error;
 

package/src/duckdb/extension/json/json_serializer.cpp

@@ -227,7 +227,7 @@ void JsonSerializer::WriteValue(const string_t value) {
 	if (skip_if_empty && value.GetSize() == 0) {
 		return;
 	}
-	auto val = yyjson_mut_strncpy(doc, value.GetDataUnsafe(), value.GetSize());
+	auto val = yyjson_mut_strncpy(doc, value.GetData(), value.GetSize());
 	PushValue(val);
 }
 

package/src/duckdb/extension/parquet/column_reader.cpp

@@ -685,7 +685,7 @@ void StringColumnReader::PrepareDeltaByteArray(ResizeableBuffer &buffer) {
 			if (i == 0 || prefix_data[i] > string_data[i - 1].GetSize()) {
 				throw std::runtime_error("DELTA_BYTE_ARRAY - prefix is out of range - corrupt file?");
 			}
-			memcpy(result_data, string_data[i - 1].GetDataUnsafe(), prefix_data[i]);
+			memcpy(result_data, string_data[i - 1].GetData(), prefix_data[i]);
 		}
 		memcpy(result_data + prefix_data[i], buffer.ptr, suffix_data[i]);
 		buffer.inc(suffix_data[i]);

package/src/duckdb/extension/parquet/column_writer.cpp

@@ -1342,7 +1342,7 @@ public:
 				}
 				stats.Update(ptr[r]);
 				temp_writer.Write<uint32_t>(ptr[r].GetSize());
-				temp_writer.WriteData((const_data_ptr_t)ptr[r].GetDataUnsafe(), ptr[r].GetSize());
+				temp_writer.WriteData((const_data_ptr_t)ptr[r].GetData(), ptr[r].GetSize());
 			}
 		}
 	}
@@ -1401,7 +1401,7 @@ public:
 			stats.Update(value);
 			// write this string value to the dictionary
 			temp_writer->Write<uint32_t>(value.GetSize());
-			temp_writer->WriteData((const_data_ptr_t)(value.GetDataUnsafe()), value.GetSize());
+			temp_writer->WriteData((const_data_ptr_t)(value.GetData()), value.GetSize());
 		}
 		// flush the dictionary page and add it to the to-be-written pages
 		WriteDictionary(state, std::move(temp_writer), values.size());
@@ -1528,7 +1528,7 @@ public:
 			stats.Update(string_values[r]);
 			// write this string value to the dictionary
 			temp_writer->Write<uint32_t>(string_values[r].GetSize());
-			temp_writer->WriteData((const_data_ptr_t)string_values[r].GetDataUnsafe(), string_values[r].GetSize());
+			temp_writer->WriteData((const_data_ptr_t)string_values[r].GetData(), string_values[r].GetSize());
 		}
 		// flush the dictionary page and add it to the to-be-written pages
 		WriteDictionary(state, std::move(temp_writer), enum_count);

package/src/duckdb/src/catalog/catalog_entry/scalar_macro_catalog_entry.cpp

@@ -21,7 +21,7 @@ ScalarMacroCatalogEntry::ScalarMacroCatalogEntry(Catalog *catalog, SchemaCatalog
 
 void ScalarMacroCatalogEntry::Serialize(Serializer &main_serializer) const {
 	D_ASSERT(!internal);
-	auto &scalar_function = (ScalarMacroFunction &)*function;
+	auto &scalar_function = function->Cast<ScalarMacroFunction>();
 	FieldWriter writer(main_serializer);
 	writer.WriteString(schema->name);
 	writer.WriteString(name);
@@ -66,7 +66,7 @@ void TableMacroCatalogEntry::Serialize(Serializer &main_serializer) const {
 	D_ASSERT(!internal);
 	FieldWriter writer(main_serializer);
 
-	auto &table_function = (TableMacroFunction &)*function;
+	auto &table_function = function->Cast<TableMacroFunction>();
 	writer.WriteString(schema->name);
 	writer.WriteString(name);
 	writer.WriteSerializable(*table_function.query_node);

package/src/duckdb/src/common/arrow/arrow_appender.cpp

@@ -195,7 +195,7 @@ struct ArrowEnumData : public ArrowScalarBaseData<TGT> {
 		return input.GetSize();
 	}
 	static void WriteData(data_ptr_t target, string_t input) {
-		memcpy(target, input.GetDataUnsafe(), input.GetSize());
+		memcpy(target, input.GetData(), input.GetSize());
 	}
 	static void EnumAppendVector(ArrowAppendData &append_data, const Vector &input, idx_t size) {
 		D_ASSERT(input.GetVectorType() == VectorType::FLAT_VECTOR);
@@ -301,7 +301,7 @@ struct ArrowVarcharConverter {
 
 	template <class SRC>
 	static void WriteData(data_ptr_t target, SRC input) {
-		memcpy(target, input.GetDataUnsafe(), input.GetSize());
+		memcpy(target, input.GetData(), input.GetSize());
 	}
 };
 

package/src/duckdb/src/common/operator/cast_operators.cpp

@@ -1097,7 +1097,7 @@ static inline bool TrySimpleIntegerCast(const char *buf, idx_t len, T &result, b
 
 template <>
 bool TryCast::Operation(string_t input, bool &result, bool strict) {
-	auto input_data = input.GetDataUnsafe();
+	auto input_data = input.GetData();
 	auto input_size = input.GetSize();
 
 	switch (input_size) {
@@ -1141,36 +1141,36 @@ bool TryCast::Operation(string_t input, bool &result, bool strict) {
 }
 template <>
 bool TryCast::Operation(string_t input, int8_t &result, bool strict) {
-	return TrySimpleIntegerCast<int8_t>(input.GetDataUnsafe(), input.GetSize(), result, strict);
+	return TrySimpleIntegerCast<int8_t>(input.GetData(), input.GetSize(), result, strict);
 }
 template <>
 bool TryCast::Operation(string_t input, int16_t &result, bool strict) {
-	return TrySimpleIntegerCast<int16_t>(input.GetDataUnsafe(), input.GetSize(), result, strict);
+	return TrySimpleIntegerCast<int16_t>(input.GetData(), input.GetSize(), result, strict);
 }
 template <>
 bool TryCast::Operation(string_t input, int32_t &result, bool strict) {
-	return TrySimpleIntegerCast<int32_t>(input.GetDataUnsafe(), input.GetSize(), result, strict);
+	return TrySimpleIntegerCast<int32_t>(input.GetData(), input.GetSize(), result, strict);
 }
 template <>
 bool TryCast::Operation(string_t input, int64_t &result, bool strict) {
-	return TrySimpleIntegerCast<int64_t>(input.GetDataUnsafe(), input.GetSize(), result, strict);
+	return TrySimpleIntegerCast<int64_t>(input.GetData(), input.GetSize(), result, strict);
 }
 
 template <>
 bool TryCast::Operation(string_t input, uint8_t &result, bool strict) {
-	return TrySimpleIntegerCast<uint8_t, false>(input.GetDataUnsafe(), input.GetSize(), result, strict);
+	return TrySimpleIntegerCast<uint8_t, false>(input.GetData(), input.GetSize(), result, strict);
 }
 template <>
 bool TryCast::Operation(string_t input, uint16_t &result, bool strict) {
-	return TrySimpleIntegerCast<uint16_t, false>(input.GetDataUnsafe(), input.GetSize(), result, strict);
+	return TrySimpleIntegerCast<uint16_t, false>(input.GetData(), input.GetSize(), result, strict);
 }
 template <>
 bool TryCast::Operation(string_t input, uint32_t &result, bool strict) {
-	return TrySimpleIntegerCast<uint32_t, false>(input.GetDataUnsafe(), input.GetSize(), result, strict);
+	return TrySimpleIntegerCast<uint32_t, false>(input.GetData(), input.GetSize(), result, strict);
 }
 template <>
 bool TryCast::Operation(string_t input, uint64_t &result, bool strict) {
-	return TrySimpleIntegerCast<uint64_t, false>(input.GetDataUnsafe(), input.GetSize(), result, strict);
+	return TrySimpleIntegerCast<uint64_t, false>(input.GetData(), input.GetSize(), result, strict);
 }
 
 template <class T, char decimal_separator = '.'>
@@ -1213,17 +1213,17 @@ static bool TryDoubleCast(const char *buf, idx_t len, T &result, bool strict) {
 
 template <>
 bool TryCast::Operation(string_t input, float &result, bool strict) {
-	return TryDoubleCast<float>(input.GetDataUnsafe(), input.GetSize(), result, strict);
+	return TryDoubleCast<float>(input.GetData(), input.GetSize(), result, strict);
 }
 
 template <>
 bool TryCast::Operation(string_t input, double &result, bool strict) {
-	return TryDoubleCast<double>(input.GetDataUnsafe(), input.GetSize(), result, strict);
+	return TryDoubleCast<double>(input.GetData(), input.GetSize(), result, strict);
 }
 
 template <>
 bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result, string *error_message, bool strict) {
-	if (!TryDoubleCast<float, ','>(input.GetDataUnsafe(), input.GetSize(), result, strict)) {
+	if (!TryDoubleCast<float, ','>(input.GetData(), input.GetSize(), result, strict)) {
 		HandleCastError::AssignError(StringUtil::Format("Could not cast string to float: \"%s\"", input.GetString()),
 		                             error_message);
 		return false;
@@ -1233,7 +1233,7 @@ bool TryCastErrorMessageCommaSeparated::Operation(string_t input, float &result,
 
 template <>
 bool TryCastErrorMessageCommaSeparated::Operation(string_t input, double &result, string *error_message, bool strict) {
-	if (!TryDoubleCast<double, ','>(input.GetDataUnsafe(), input.GetSize(), result, strict)) {
+	if (!TryDoubleCast<double, ','>(input.GetData(), input.GetSize(), result, strict)) {
 		HandleCastError::AssignError(StringUtil::Format("Could not cast string to double: \"%s\"", input.GetString()),
 		                             error_message);
 		return false;
@@ -1518,12 +1518,12 @@ template <>
 bool TryCast::Operation(string_t input, date_t &result, bool strict) {
 	idx_t pos;
 	bool special = false;
-	return Date::TryConvertDate(input.GetDataUnsafe(), input.GetSize(), pos, result, special, strict);
+	return Date::TryConvertDate(input.GetData(), input.GetSize(), pos, result, special, strict);
 }
 
 template <>
 date_t Cast::Operation(string_t input) {
-	return Date::FromCString(input.GetDataUnsafe(), input.GetSize());
+	return Date::FromCString(input.GetData(), input.GetSize());
 }
 
 //===--------------------------------------------------------------------===//
@@ -1541,12 +1541,12 @@ bool TryCastErrorMessage::Operation(string_t input, dtime_t &result, string *err
 template <>
 bool TryCast::Operation(string_t input, dtime_t &result, bool strict) {
 	idx_t pos;
-	return Time::TryConvertTime(input.GetDataUnsafe(), input.GetSize(), pos, result, strict);
+	return Time::TryConvertTime(input.GetData(), input.GetSize(), pos, result, strict);
 }
 
 template <>
 dtime_t Cast::Operation(string_t input) {
-	return Time::FromCString(input.GetDataUnsafe(), input.GetSize());
+	return Time::FromCString(input.GetData(), input.GetSize());
 }
 
 //===--------------------------------------------------------------------===//
@@ -1554,7 +1554,7 @@ dtime_t Cast::Operation(string_t input) {
 //===--------------------------------------------------------------------===//
 template <>
 bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, string *error_message, bool strict) {
-	auto cast_result = Timestamp::TryConvertTimestamp(input.GetDataUnsafe(), input.GetSize(), result);
+	auto cast_result = Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result);
 	if (cast_result == TimestampCastResult::SUCCESS) {
 		return true;
 	}
@@ -1568,13 +1568,12 @@ bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, string
 
 template <>
 bool TryCast::Operation(string_t input, timestamp_t &result, bool strict) {
-	return Timestamp::TryConvertTimestamp(input.GetDataUnsafe(), input.GetSize(), result) ==
-	       TimestampCastResult::SUCCESS;
+	return Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result) == TimestampCastResult::SUCCESS;
 }
 
 template <>
 timestamp_t Cast::Operation(string_t input) {
-	return Timestamp::FromCString(input.GetDataUnsafe(), input.GetSize());
+	return Timestamp::FromCString(input.GetData(), input.GetSize());
 }
 
 //===--------------------------------------------------------------------===//
@@ -1582,7 +1581,7 @@ timestamp_t Cast::Operation(string_t input) {
 //===--------------------------------------------------------------------===//
 template <>
 bool TryCastErrorMessage::Operation(string_t input, interval_t &result, string *error_message, bool strict) {
-	return Interval::FromCString(input.GetDataUnsafe(), input.GetSize(), result, error_message, strict);
+	return Interval::FromCString(input.GetData(), input.GetSize(), result, error_message, strict);
 }
 
 //===--------------------------------------------------------------------===//
@@ -1715,8 +1714,8 @@ struct HugeIntegerCastOperation {
 template <>
 bool TryCast::Operation(string_t input, hugeint_t &result, bool strict) {
 	HugeIntCastData data;
-	if (!TryIntegerCast<HugeIntCastData, true, true, HugeIntegerCastOperation>(input.GetDataUnsafe(), input.GetSize(),
-	                                                                           data, strict)) {
+	if (!TryIntegerCast<HugeIntCastData, true, true, HugeIntegerCastOperation>(input.GetData(), input.GetSize(), data,
+	                                                                           strict)) {
 		return false;
 	}
 	result = data.hugeint;
@@ -1916,7 +1915,7 @@ bool TryDecimalStringCast(string_t input, T &result, string *error_message, uint
 	state.round_set = false;
 	state.should_round = false;
 	if (!TryIntegerCast<DecimalCastData<T>, true, true, DecimalCastOperation, false, decimal_separator>(
-	        input.GetDataUnsafe(), input.GetSize(), state, false)) {
+	        input.GetData(), input.GetSize(), state, false)) {
 		string error = StringUtil::Format("Could not convert string \"%s\" to DECIMAL(%d,%d)", input.GetString(),
 		                                  (int)width, (int)scale);
 		HandleCastError::AssignError(error, error_message);

package/src/duckdb/src/common/row_operations/row_heap_scatter.cpp

@@ -163,7 +163,7 @@ static void HeapScatterStringVector(Vector &v, idx_t vcount, const SelectionVect
 				Store<uint32_t>(string_entry.GetSize(), key_locations[i]);
 				key_locations[i] += sizeof(uint32_t);
 				// store the string
-				memcpy(key_locations[i], string_entry.GetDataUnsafe(), string_entry.GetSize());
+				memcpy(key_locations[i], string_entry.GetData(), string_entry.GetSize());
 				key_locations[i] += string_entry.GetSize();
 			}
 		}
@@ -181,7 +181,7 @@ static void HeapScatterStringVector(Vector &v, idx_t vcount, const SelectionVect
 				Store<uint32_t>(string_entry.GetSize(), key_locations[i]);
 				key_locations[i] += sizeof(uint32_t);
 				// store the string
-				memcpy(key_locations[i], string_entry.GetDataUnsafe(), string_entry.GetSize());
+				memcpy(key_locations[i], string_entry.GetData(), string_entry.GetSize());
 				key_locations[i] += string_entry.GetSize();
 			} else {
 				// set the validitymask

package/src/duckdb/src/common/row_operations/row_scatter.cpp

@@ -82,7 +82,7 @@ static void ScatterStringVector(UnifiedVectorFormat &col, Vector &rows, data_ptr
 		} else {
 			const auto &str = string_data[col_idx];
 			string_t inserted((const char *)str_locations[i], str.GetSize());
-			memcpy(inserted.GetDataWriteable(), str.GetDataUnsafe(), str.GetSize());
+			memcpy(inserted.GetDataWriteable(), str.GetData(), str.GetSize());
 			str_locations[i] += str.GetSize();
 			inserted.Finalize();
 			Store<string_t>(inserted, row + col_offset);