duckdb 0.7.2-dev3710.0 → 0.7.2-dev3763.0

package/package.json

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

package/src/database.cpp

@@ -328,7 +328,6 @@ ScanReplacement(duckdb::ClientContext &context, const std::string &table_name, d
 			children.push_back(duckdb::make_uniq<duckdb::ConstantExpression>(std::move(param)));
 		}
 		table_function->function = duckdb::make_uniq<duckdb::FunctionExpression>(jsargs.function, std::move(children));
-		table_function->alias = table_name;
 		return std::move(table_function);
 	}
 	return nullptr;

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

@@ -161,7 +161,7 @@ unique_ptr<FunctionData> ReadJSONBind(ClientContext &context, TableFunctionBindI
 			StrpTimeFormat format;
 			auto error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
 			if (!error.empty()) {
-				throw InvalidInputException("read_json could not parse \"dateformat\": '%s'.", error.c_str());
+				throw BinderException("read_json could not parse \"dateformat\": '%s'.", error.c_str());
 			}
 		} else if (loption == "timestampformat" || loption == "timestamp_format") {
 			auto format_string = StringValue::Get(kv.second);
@@ -173,7 +173,7 @@ unique_ptr<FunctionData> ReadJSONBind(ClientContext &context, TableFunctionBindI
 			StrpTimeFormat format;
 			auto error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
 			if (!error.empty()) {
-				throw InvalidInputException("read_json could not parse \"timestampformat\": '%s'.", error.c_str());
+				throw BinderException("read_json could not parse \"timestampformat\": '%s'.", error.c_str());
 			}
 		} else if (loption == "records") {
 			auto arg = StringValue::Get(kv.second);
@@ -184,7 +184,7 @@ unique_ptr<FunctionData> ReadJSONBind(ClientContext &context, TableFunctionBindI
 			} else if (arg == "false") {
 				bind_data->options.record_type = JSONRecordType::VALUES;
 			} else {
-				throw InvalidInputException("read_json requires \"records\" to be one of ['auto', 'true', 'false'].");
+				throw BinderException("read_json requires \"records\" to be one of ['auto', 'true', 'false'].");
 			}
 		}
 	}

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

@@ -28,19 +28,23 @@ void JSONScanData::Bind(ClientContext &context, TableFunctionBindInput &input) {
 		} else if (loption == "maximum_object_size") {
 			maximum_object_size = MaxValue<idx_t>(UIntegerValue::Get(kv.second), maximum_object_size);
 		} else if (loption == "format") {
-			auto arg = StringValue::Get(kv.second);
-			if (arg == "auto") {
-				options.format = JSONFormat::AUTO_DETECT;
-			} else if (arg == "unstructured") {
-				options.format = JSONFormat::UNSTRUCTURED;
-			} else if (arg == "newline_delimited" || arg == "nd") {
-				options.format = JSONFormat::NEWLINE_DELIMITED;
-			} else if (arg == "array") {
-				options.format = JSONFormat::ARRAY;
-			} else {
-				throw InvalidInputException(
-				    "format must be one of ['auto', 'unstructured', 'newline_delimited', 'array']");
+			auto arg = StringUtil::Lower(StringValue::Get(kv.second));
+			static const auto format_options =
+			    case_insensitive_map_t<JSONFormat> {{"auto", JSONFormat::AUTO_DETECT},
+			                                        {"unstructured", JSONFormat::UNSTRUCTURED},
+			                                        {"newline_delimited", JSONFormat::NEWLINE_DELIMITED},
+			                                        {"nd", JSONFormat::NEWLINE_DELIMITED},
+			                                        {"array", JSONFormat::ARRAY}};
+			auto lookup = format_options.find(arg);
+			if (lookup == format_options.end()) {
+				vector<string> valid_options;
+				for (auto &pair : format_options) {
+					valid_options.push_back(StringUtil::Format("'%s'", pair.first));
+				}
+				throw BinderException("format must be one of [%s], not '%s'", StringUtil::Join(valid_options, ", "),
+				                      arg);
 			}
+			options.format = lookup->second;
 		} else if (loption == "compression") {
 			SetCompression(StringUtil::Lower(StringValue::Get(kv.second)));
 		}

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

@@ -33,7 +33,7 @@ struct DuckDBArrowSchemaHolder {
 	std::list<vector<ArrowSchema>> nested_children;
 	std::list<vector<ArrowSchema *>> nested_children_ptr;
 	//! This holds strings created to represent decimal types
-	vector<unsafe_array_ptr<char>> owned_type_names;
+	vector<unsafe_unique_array<char>> owned_type_names;
 };
 
 static void ReleaseDuckDBArrowSchema(ArrowSchema *schema) {
@@ -131,7 +131,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		break;
 	case LogicalTypeId::TIMESTAMP_TZ: {
 		string format = "tsu:" + config_timezone;
-		auto format_ptr = make_unsafe_array<char>(format.size() + 1);
+		auto format_ptr = make_unsafe_uniq_array<char>(format.size() + 1);
 		for (size_t i = 0; i < format.size(); i++) {
 			format_ptr[i] = format[i];
 		}
@@ -156,7 +156,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		uint8_t width, scale;
 		type.GetDecimalProperties(width, scale);
 		string format = "d:" + to_string(width) + "," + to_string(scale);
-		auto format_ptr = make_unsafe_array<char>(format.size() + 1);
+		auto format_ptr = make_unsafe_uniq_array<char>(format.size() + 1);
 		for (size_t i = 0; i < format.size(); i++) {
 			format_ptr[i] = format[i];
 		}
@@ -204,7 +204,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 			InitializeChild(*child.children[type_idx]);
 
 			auto &struct_col_name = child_types[type_idx].first;
-			auto name_ptr = make_unsafe_array<char>(struct_col_name.size() + 1);
+			auto name_ptr = make_unsafe_uniq_array<char>(struct_col_name.size() + 1);
 			for (size_t i = 0; i < struct_col_name.size(); i++) {
 				name_ptr[i] = struct_col_name[i];
 			}

package/src/duckdb/src/common/compressed_file_system.cpp

@@ -19,10 +19,10 @@ void CompressedFile::Initialize(bool write) {
 	this->write = write;
 	stream_data.in_buf_size = compressed_fs.InBufferSize();
 	stream_data.out_buf_size = compressed_fs.OutBufferSize();
-	stream_data.in_buff = make_unsafe_array<data_t>(stream_data.in_buf_size);
+	stream_data.in_buff = make_unsafe_uniq_array<data_t>(stream_data.in_buf_size);
 	stream_data.in_buff_start = stream_data.in_buff.get();
 	stream_data.in_buff_end = stream_data.in_buff.get();
-	stream_data.out_buff = make_unsafe_array<data_t>(stream_data.out_buf_size);
+	stream_data.out_buff = make_unsafe_uniq_array<data_t>(stream_data.out_buf_size);
 	stream_data.out_buff_start = stream_data.out_buff.get();
 	stream_data.out_buff_end = stream_data.out_buff.get();
 

package/src/duckdb/src/common/file_system.cpp

@@ -87,7 +87,7 @@ idx_t FileSystem::GetAvailableMemory() {
 }
 
 string FileSystem::GetWorkingDirectory() {
-	auto buffer = make_unsafe_array<char>(PATH_MAX);
+	auto buffer = make_unsafe_uniq_array<char>(PATH_MAX);
 	char *ret = getcwd(buffer.get(), PATH_MAX);
 	if (!ret) {
 		throw IOException("Could not get working directory!");
@@ -170,7 +170,7 @@ string FileSystem::GetWorkingDirectory() {
 	if (count == 0) {
 		throw IOException("Could not get working directory!");
 	}
-	auto buffer = make_unsafe_array<wchar_t>(count);
+	auto buffer = make_unsafe_uniq_array<wchar_t>(count);
 	idx_t ret = GetCurrentDirectoryW(count, buffer.get());
 	if (count != ret + 1) {
 		throw IOException("Could not get working directory!");

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

@@ -95,8 +95,8 @@ static void GatherNestedVector(Vector &rows, const SelectionVector &row_sel, Vec
 	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
 
 	// Build the gather locations
-	auto data_locations = make_unsafe_array<data_ptr_t>(count);
-	auto mask_locations = make_unsafe_array<data_ptr_t>(count);
+	auto data_locations = make_unsafe_uniq_array<data_ptr_t>(count);
+	auto mask_locations = make_unsafe_uniq_array<data_ptr_t>(count);
 	for (idx_t i = 0; i < count; i++) {
 		auto row_idx = row_sel.get_index(i);
 		auto row = ptrs[row_idx];

package/src/duckdb/src/common/serializer/binary_deserializer.cpp

@@ -123,7 +123,7 @@ string BinaryDeserializer::ReadString() {
 	if (size == 0) {
 		return string();
 	}
-	auto buffer = make_unsafe_array<data_t>(size);
+	auto buffer = make_unsafe_uniq_array<data_t>(size);
 	ReadData(buffer.get(), size);
 	return string((char *)buffer.get(), size);
 }

package/src/duckdb/src/common/serializer/buffered_file_reader.cpp

@@ -9,7 +9,7 @@ namespace duckdb {
 
 BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, optional_ptr<ClientContext> context,
                                        FileLockType lock_type, optional_ptr<FileOpener> opener)
-    : fs(fs), data(make_unsafe_array<data_t>(FILE_BUFFER_SIZE)), offset(0), read_data(0), total_read(0),
+    : fs(fs), data(make_unsafe_uniq_array<data_t>(FILE_BUFFER_SIZE)), offset(0), read_data(0), total_read(0),
       context(context) {
 	handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ, lock_type, FileSystem::DEFAULT_COMPRESSION, opener.get());
 	file_size = fs.GetFileSize(*handle);

package/src/duckdb/src/common/serializer/buffered_file_writer.cpp

@@ -9,7 +9,7 @@ namespace duckdb {
 constexpr uint8_t BufferedFileWriter::DEFAULT_OPEN_FLAGS;
 
 BufferedFileWriter::BufferedFileWriter(FileSystem &fs, const string &path_p, uint8_t open_flags)
-    : fs(fs), path(path_p), data(make_unsafe_array<data_t>(FILE_BUFFER_SIZE)), offset(0), total_written(0) {
+    : fs(fs), path(path_p), data(make_unsafe_uniq_array<data_t>(FILE_BUFFER_SIZE)), offset(0), total_written(0) {
 	handle = fs.OpenFile(path, open_flags, FileLockType::WRITE_LOCK);
 }
 

package/src/duckdb/src/common/serializer/buffered_serializer.cpp

@@ -5,10 +5,10 @@
 namespace duckdb {
 
 BufferedSerializer::BufferedSerializer(idx_t maximum_size)
-    : BufferedSerializer(make_unsafe_array<data_t>(maximum_size), maximum_size) {
+    : BufferedSerializer(make_unsafe_uniq_array<data_t>(maximum_size), maximum_size) {
 }
 
-BufferedSerializer::BufferedSerializer(unsafe_array_ptr<data_t> data, idx_t size)
+BufferedSerializer::BufferedSerializer(unsafe_unique_array<data_t> data, idx_t size)
     : maximum_size(size), data(data.get()) {
 	blob.size = 0;
 	blob.data = std::move(data);
@@ -26,7 +26,7 @@ void BufferedSerializer::WriteData(const_data_ptr_t buffer, idx_t write_size) {
 		auto new_data = new data_t[maximum_size];
 		memcpy(new_data, data, blob.size);
 		data = new_data;
-		blob.data = unsafe_array_ptr<data_t>(new_data);
+		blob.data = unsafe_unique_array<data_t>(new_data);
 	}
 
 	memcpy(data + blob.size, buffer, write_size);

package/src/duckdb/src/common/serializer.cpp

@@ -8,7 +8,7 @@ string Deserializer::Read() {
 	if (size == 0) {
 		return string();
 	}
-	auto buffer = make_unsafe_array<data_t>(size);
+	auto buffer = make_unsafe_uniq_array<data_t>(size);
 	ReadData(buffer.get(), size);
 	return string((char *)buffer.get(), size);
 }

package/src/duckdb/src/common/sort/radix_sort.cpp

@@ -17,7 +17,7 @@ static void SortTiedBlobs(BufferManager &buffer_manager, const data_ptr_t datapt
 		return;
 	}
 	// Fill pointer array for sorting
-	auto ptr_block = make_unsafe_array<data_ptr_t>(end - start);
+	auto ptr_block = make_unsafe_uniq_array<data_ptr_t>(end - start);
 	auto entry_ptrs = (data_ptr_t *)ptr_block.get();
 	for (idx_t i = start; i < end; i++) {
 		entry_ptrs[i - start] = row_ptr;
@@ -158,7 +158,7 @@ inline void InsertionSort(const data_ptr_t orig_ptr, const data_ptr_t temp_ptr,
 	const data_ptr_t target_ptr = swap ? orig_ptr : temp_ptr;
 	if (count > 1) {
 		const idx_t total_offset = col_offset + offset;
-		auto temp_val = make_unsafe_array<data_t>(row_width);
+		auto temp_val = make_unsafe_uniq_array<data_t>(row_width);
 		const data_ptr_t val = temp_val.get();
 		const auto comp_width = total_comp_width - offset;
 		for (idx_t i = 1; i < count; i++) {
@@ -249,7 +249,7 @@ void RadixSort(BufferManager &buffer_manager, const data_ptr_t &dataptr, const i
 		RadixSortLSD(buffer_manager, dataptr, count, col_offset, sort_layout.entry_size, sorting_size);
 	} else {
 		auto temp_block = buffer_manager.Allocate(MaxValue(count * sort_layout.entry_size, (idx_t)Storage::BLOCK_SIZE));
-		auto preallocated_array = make_unsafe_array<idx_t>(sorting_size * SortConstants::MSD_RADIX_LOCATIONS);
+		auto preallocated_array = make_unsafe_uniq_array<idx_t>(sorting_size * SortConstants::MSD_RADIX_LOCATIONS);
 		RadixSortMSD(dataptr, temp_block.Ptr(), count, col_offset, sort_layout.entry_size, sorting_size, 0,
 		             preallocated_array.get(), false);
 	}
@@ -291,7 +291,7 @@ void LocalSortState::SortInMemory() {
 	// Radix sort and break ties until no more ties, or until all columns are sorted
 	idx_t sorting_size = 0;
 	idx_t col_offset = 0;
-	unsafe_array_ptr<bool> ties_ptr;
+	unsafe_unique_array<bool> ties_ptr;
 	bool *ties = nullptr;
 	bool contains_string = false;
 	for (idx_t i = 0; i < sort_layout->column_count; i++) {
@@ -305,7 +305,7 @@ void LocalSortState::SortInMemory() {
 		if (!ties) {
 			// This is the first sort
 			RadixSort(*buffer_manager, dataptr, count, col_offset, sorting_size, *sort_layout, contains_string);
-			ties_ptr = make_unsafe_array<bool>(count);
+			ties_ptr = make_unsafe_uniq_array<bool>(count);
 			ties = ties_ptr.get();
 			std::fill_n(ties, count - 1, true);
 			ties[count - 1] = false;

package/src/duckdb/src/common/string_util.cpp

@@ -193,6 +193,10 @@ string StringUtil::Lower(const string &str) {
 	return (copy);
 }
 
+bool StringUtil::IsLower(const string &str) {
+	return str == Lower(str);
+}
+
 // Jenkins hash function: https://en.wikipedia.org/wiki/Jenkins_hash_function
 uint64_t StringUtil::CIHash(const string &str) {
 	uint32_t hash = 0;
@@ -277,7 +281,7 @@ vector<string> StringUtil::TopNStrings(vector<pair<string, idx_t>> scores, idx_t
 
 struct LevenshteinArray {
 	LevenshteinArray(idx_t len1, idx_t len2) : len1(len1) {
-		dist = make_unsafe_array<idx_t>(len1 * len2);
+		dist = make_unsafe_uniq_array<idx_t>(len1 * len2);
 	}
 
 	idx_t &Score(idx_t i, idx_t j) {
@@ -286,7 +290,7 @@ struct LevenshteinArray {
 
 private:
 	idx_t len1;
-	unsafe_array_ptr<idx_t> dist;
+	unsafe_unique_array<idx_t> dist;
 
 	idx_t GetIndex(idx_t i, idx_t j) {
 		return j * len1 + i;

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

@@ -78,7 +78,7 @@ void Bit::ToString(string_t bits, char *output) {
 
 string Bit::ToString(string_t str) {
 	auto len = BitLength(str);
-	auto buffer = make_unsafe_array<char>(len);
+	auto buffer = make_unsafe_uniq_array<char>(len);
 	ToString(str, buffer.get());
 	return string(buffer.get(), len);
 }
@@ -140,7 +140,7 @@ void Bit::ToBit(string_t str, string_t &output_str) {
 
 string Bit::ToBit(string_t str) {
 	auto bit_len = GetBitSize(str);
-	auto buffer = make_unsafe_array<char>(bit_len);
+	auto buffer = make_unsafe_uniq_array<char>(bit_len);
 	string_t output_str(buffer.get(), bit_len);
 	Bit::ToBit(str, output_str);
 	return output_str.GetString();

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

@@ -64,7 +64,7 @@ void Blob::ToString(string_t blob, char *output) {
 
 string Blob::ToString(string_t blob) {
 	auto str_len = GetStringSize(blob);
-	auto buffer = make_unsafe_array<char>(str_len);
+	auto buffer = make_unsafe_uniq_array<char>(str_len);
 	Blob::ToString(blob, buffer.get());
 	return string(buffer.get(), str_len);
 }
@@ -136,7 +136,7 @@ void Blob::ToBlob(string_t str, data_ptr_t output) {
 
 string Blob::ToBlob(string_t str) {
 	auto blob_len = GetBlobSize(str);
-	auto buffer = make_unsafe_array<char>(blob_len);
+	auto buffer = make_unsafe_uniq_array<char>(blob_len);
 	Blob::ToBlob(str, (data_ptr_t)buffer.get());
 	return string(buffer.get(), blob_len);
 }

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

@@ -291,8 +291,8 @@ void DataChunk::Slice(DataChunk &other, const SelectionVector &sel, idx_t count_
 	}
 }
 
-unsafe_array_ptr<UnifiedVectorFormat> DataChunk::ToUnifiedFormat() {
-	auto orrified_data = make_unsafe_array<UnifiedVectorFormat>(ColumnCount());
+unsafe_unique_array<UnifiedVectorFormat> DataChunk::ToUnifiedFormat() {
+	auto orrified_data = make_unsafe_uniq_array<UnifiedVectorFormat>(ColumnCount());
 	for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
 		data[col_idx].ToUnifiedFormat(size(), orrified_data[col_idx]);
 	}

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

@@ -362,7 +362,7 @@ string Date::ToString(date_t date) {
 	Date::Convert(date, date_units[0], date_units[1], date_units[2]);
 
 	auto length = DateToStringCast::Length(date_units, year_length, add_bc);
-	auto buffer = make_unsafe_array<char>(length);
+	auto buffer = make_unsafe_uniq_array<char>(length);
 	DateToStringCast::Format(buffer.get(), date_units, year_length, add_bc);
 	return string(buffer.get(), length);
 }

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

@@ -6,7 +6,7 @@ namespace duckdb {
 template <class SIGNED, class UNSIGNED>
 string TemplatedDecimalToString(SIGNED value, uint8_t width, uint8_t scale) {
 	auto len = DecimalToString::DecimalLength<SIGNED, UNSIGNED>(value, width, scale);
-	auto data = make_unsafe_array<char>(len + 1);
+	auto data = make_unsafe_uniq_array<char>(len + 1);
 	DecimalToString::FormatDecimal<SIGNED, UNSIGNED>(value, width, scale, data.get(), len);
 	return string(data.get(), len);
 }
@@ -25,7 +25,7 @@ string Decimal::ToString(int64_t value, uint8_t width, uint8_t scale) {
 
 string Decimal::ToString(hugeint_t value, uint8_t width, uint8_t scale) {
 	auto len = HugeintToStringCast::DecimalLength(value, width, scale);
-	auto data = make_unsafe_array<char>(len + 1);
+	auto data = make_unsafe_uniq_array<char>(len + 1);
 	HugeintToStringCast::FormatDecimal(value, width, scale, data.get(), len);
 	return string(data.get(), len);
 }

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

@@ -5,7 +5,7 @@
 namespace duckdb {
 
 SelectionData::SelectionData(idx_t count) {
-	owned_data = make_unsafe_array<sel_t>(count);
+	owned_data = make_unsafe_uniq_array<sel_t>(count);
 #ifdef DEBUG
 	for (idx_t i = 0; i < count; i++) {
 		owned_data[i] = std::numeric_limits<sel_t>::max();

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

@@ -158,7 +158,7 @@ string Time::ToString(dtime_t time) {
 
 	char micro_buffer[6];
 	auto length = TimeToStringCast::Length(time_units, micro_buffer);
-	auto buffer = make_unsafe_array<char>(length);
+	auto buffer = make_unsafe_uniq_array<char>(length);
 	TimeToStringCast::Format(buffer.get(), length, time_units, micro_buffer);
 	return string(buffer.get(), length);
 }

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

@@ -297,7 +297,7 @@ void Vector::Resize(idx_t cur_size, idx_t new_size) {
 	}
 	for (auto &data_to_resize : to_resize) {
 		if (!data_to_resize.is_nested) {
-			auto new_data = make_unsafe_array<data_t>(new_size * data_to_resize.type_size);
+			auto new_data = make_unsafe_uniq_array<data_t>(new_size * data_to_resize.type_size);
 			memcpy(new_data.get(), data_to_resize.data, cur_size * data_to_resize.type_size * sizeof(data_t));
 			data_to_resize.buffer->SetData(std::move(new_data));
 			data_to_resize.vec.data = data_to_resize.buffer->GetData();
@@ -920,7 +920,7 @@ void Vector::Serialize(idx_t count, Serializer &serializer) {
 	if (TypeIsConstantSize(type.InternalType())) {
 		// constant size type: simple copy
 		idx_t write_size = GetTypeIdSize(type.InternalType()) * count;
-		auto ptr = make_unsafe_array<data_t>(write_size);
+		auto ptr = make_unsafe_uniq_array<data_t>(write_size);
 		VectorOperations::WriteToStorage(*this, count, ptr.get());
 		serializer.WriteData(ptr.get(), write_size);
 	} else {
@@ -947,7 +947,7 @@ void Vector::Serialize(idx_t count, Serializer &serializer) {
 			auto list_size = ListVector::GetListSize(*this);
 
 			// serialize the list entries in a flat array
-			auto data = make_unsafe_array<list_entry_t>(count);
+			auto data = make_unsafe_uniq_array<list_entry_t>(count);
 			auto source_array = (list_entry_t *)vdata.data;
 			for (idx_t i = 0; i < count; i++) {
 				auto idx = vdata.sel->get_index(i);
@@ -988,7 +988,7 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 	if (TypeIsConstantSize(logical_type.InternalType())) {
 		// constant size type: simple copy
 		idx_t write_size = GetTypeIdSize(logical_type.InternalType()) * count;
-		auto ptr = make_unsafe_array<data_t>(write_size);
+		auto ptr = make_unsafe_uniq_array<data_t>(write_size);
 		VectorOperations::WriteToStorage(*this, count, ptr.get());
 		serializer.WriteProperty("data", ptr.get(), write_size);
 	} else {
@@ -1027,7 +1027,7 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 			auto list_size = ListVector::GetListSize(*this);
 
 			// serialize the list entries in a flat array
-			auto entries = make_unsafe_array<list_entry_t>(count);
+			auto entries = make_unsafe_uniq_array<list_entry_t>(count);
 			auto source_array = (list_entry_t *)vdata.data;
 			for (idx_t i = 0; i < count; i++) {
 				auto idx = vdata.sel->get_index(i);
@@ -1071,7 +1071,7 @@ void Vector::FormatDeserialize(FormatDeserializer &deserializer, idx_t count) {
 	if (TypeIsConstantSize(logical_type.InternalType())) {
 		// constant size type: read fixed amount of data
 		auto column_size = GetTypeIdSize(logical_type.InternalType()) * count;
-		auto ptr = make_unsafe_array<data_t>(column_size);
+		auto ptr = make_unsafe_uniq_array<data_t>(column_size);
 		deserializer.ReadProperty("data", ptr.get(), column_size);
 
 		VectorOperations::ReadFromStorage(ptr.get(), count, *this);
@@ -1158,7 +1158,7 @@ void Vector::Deserialize(idx_t count, Deserializer &source) {
 	if (TypeIsConstantSize(type.InternalType())) {
 		// constant size type: read fixed amount of data from
 		auto column_size = GetTypeIdSize(type.InternalType()) * count;
-		auto ptr = make_unsafe_array<data_t>(column_size);
+		auto ptr = make_unsafe_uniq_array<data_t>(column_size);
 		source.ReadData(ptr.get(), column_size);
 
 		VectorOperations::ReadFromStorage(ptr.get(), count, *this);

package/src/duckdb/src/common/windows_util.cpp

@@ -11,7 +11,7 @@ std::wstring WindowsUtil::UTF8ToUnicode(const char *input) {
 	if (result_size == 0) {
 		throw IOException("Failure in MultiByteToWideChar");
 	}
-	auto buffer = make_unsafe_array<wchar_t>(result_size);
+	auto buffer = make_unsafe_uniq_array<wchar_t>(result_size);
 	result_size = MultiByteToWideChar(CP_UTF8, 0, input, -1, buffer.get(), result_size);
 	if (result_size == 0) {
 		throw IOException("Failure in MultiByteToWideChar");
@@ -26,7 +26,7 @@ static string WideCharToMultiByteWrapper(LPCWSTR input, uint32_t code_page) {
 	if (result_size == 0) {
 		throw IOException("Failure in WideCharToMultiByte");
 	}
-	auto buffer = make_unsafe_array<char>(result_size);
+	auto buffer = make_unsafe_uniq_array<char>(result_size);
 	result_size = WideCharToMultiByte(code_page, 0, input, -1, buffer.get(), result_size, 0, 0);
 	if (result_size == 0) {
 		throw IOException("Failure in WideCharToMultiByte");

package/src/duckdb/src/core_functions/scalar/list/list_aggregates.cpp

@@ -179,7 +179,7 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 
 	// state_buffer holds the state for each list of this chunk
 	idx_t size = aggr.function.state_size();
-	auto state_buffer = make_unsafe_array<data_t>(size * count);
+	auto state_buffer = make_unsafe_uniq_array<data_t>(size * count);
 
 	// state vector for initialize and finalize
 	StateVector state_vector(count, info.aggr_expr->Copy());

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

@@ -94,7 +94,7 @@ static void PrintfFunction(DataChunk &args, ExpressionState &state, Vector &resu
 
 		// now gather all the format arguments
 		vector<duckdb_fmt::basic_format_arg<CTX>> format_args;
-		vector<unsafe_array_ptr<data_t>> string_args;
+		vector<unsafe_unique_array<data_t>> string_args;
 
 		for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
 			auto &col = args.data[col_idx];

package/src/duckdb/src/execution/aggregate_hashtable.cpp

@@ -390,7 +390,7 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(AggregateHTAppendSta
 	}
 	TupleDataCollection::ToUnifiedFormat(state.chunk_state, state.group_chunk);
 	if (!state.group_data) {
-		state.group_data = make_unsafe_array<UnifiedVectorFormat>(state.group_chunk.ColumnCount());
+		state.group_data = make_unsafe_uniq_array<UnifiedVectorFormat>(state.group_chunk.ColumnCount());
 	}
 	TupleDataCollection::GetVectorData(state.chunk_state, state.group_data.get());
 

package/src/duckdb/src/execution/join_hashtable.cpp

@@ -142,7 +142,7 @@ static idx_t FilterNullValues(UnifiedVectorFormat &vdata, const SelectionVector
 	return result_count;
 }
 
-idx_t JoinHashTable::PrepareKeys(DataChunk &keys, unsafe_array_ptr<UnifiedVectorFormat> &key_data,
+idx_t JoinHashTable::PrepareKeys(DataChunk &keys, unsafe_unique_array<UnifiedVectorFormat> &key_data,
                                  const SelectionVector *&current_sel, SelectionVector &sel, bool build_side) {
 	key_data = keys.ToUnifiedFormat();
 
@@ -197,7 +197,7 @@ void JoinHashTable::Build(PartitionedTupleDataAppendState &append_state, DataChu
 	}
 
 	// prepare the keys for processing
-	unsafe_array_ptr<UnifiedVectorFormat> key_data;
+	unsafe_unique_array<UnifiedVectorFormat> key_data;
 	const SelectionVector *current_sel;
 	SelectionVector sel(STANDARD_VECTOR_SIZE);
 	idx_t added_count = PrepareKeys(keys, key_data, current_sel, sel, true);
@@ -332,7 +332,7 @@ unique_ptr<ScanStructure> JoinHashTable::InitializeScanStructure(DataChunk &keys
 	auto ss = make_uniq<ScanStructure>(*this);
 
 	if (join_type != JoinType::INNER) {
-		ss->found_match = make_unsafe_array<bool>(STANDARD_VECTOR_SIZE);
+		ss->found_match = make_unsafe_uniq_array<bool>(STANDARD_VECTOR_SIZE);
 		memset(ss->found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
 	}
 

package/src/duckdb/src/execution/operator/aggregate/physical_ungrouped_aggregate.cpp

@@ -39,7 +39,7 @@ struct AggregateState {
 		for (auto &aggregate : aggregate_expressions) {
 			D_ASSERT(aggregate->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
 			auto &aggr = aggregate->Cast<BoundAggregateExpression>();
-			auto state = make_unsafe_array<data_t>(aggr.function.state_size());
+			auto state = make_unsafe_uniq_array<data_t>(aggr.function.state_size());
 			aggr.function.initialize(state.get());
 			aggregates.push_back(std::move(state));
 			bind_data.push_back(aggr.bind_info.get());
@@ -69,7 +69,7 @@ struct AggregateState {
 	}
 
 	//! The aggregate values
-	vector<unsafe_array_ptr<data_t>> aggregates;
+	vector<unsafe_unique_array<data_t>> aggregates;
 	//! The bind data
 	vector<FunctionData *> bind_data;
 	//! The destructors

package/src/duckdb/src/execution/operator/join/outer_join_marker.cpp

@@ -10,7 +10,7 @@ void OuterJoinMarker::Initialize(idx_t count_p) {
 		return;
 	}
 	this->count = count_p;
-	found_match = make_unsafe_array<bool>(count);
+	found_match = make_unsafe_uniq_array<bool>(count);
 	Reset();
 }
 

package/src/duckdb/src/execution/operator/join/perfect_hash_join_executor.cpp

@@ -25,7 +25,7 @@ bool PerfectHashJoinExecutor::BuildPerfectHashTable(LogicalType &key_type) {
 	}
 
 	// and for duplicate_checking
-	bitmap_build_idx = make_unsafe_array<bool>(build_size);
+	bitmap_build_idx = make_unsafe_uniq_array<bool>(build_size);
 	memset(bitmap_build_idx.get(), 0, sizeof(bool) * build_size); // set false
 
 	// Now fill columns with build data

package/src/duckdb/src/execution/operator/join/physical_range_join.cpp

@@ -72,7 +72,7 @@ void PhysicalRangeJoin::GlobalSortedTable::Combine(LocalSortedTable &ltable) {
 }
 
 void PhysicalRangeJoin::GlobalSortedTable::IntializeMatches() {
-	found_match = make_unsafe_array<bool>(Count());
+	found_match = make_unsafe_uniq_array<bool>(Count());
 	memset(found_match.get(), 0, sizeof(bool) * Count());
 }
 

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

@@ -1425,7 +1425,7 @@ bool BufferedCSVReader::ReadBuffer(idx_t &start, idx_t &line_start) {
 		                            GetLineNumberStr(linenr, linenr_estimated));
 	}
 
-	buffer = make_unsafe_array<char>(buffer_read_size + remaining + 1);
+	buffer = make_unsafe_uniq_array<char>(buffer_read_size + remaining + 1);
 	buffer_size = remaining + buffer_read_size;
 	if (remaining > 0) {
 		// remaining from last buffer: copy it here