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

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

@@ -18,15 +18,24 @@ PartitionGlobalHashGroup::PartitionGlobalHashGroup(BufferManager &buffer_manager
 	global_sort = make_uniq<GlobalSortState>(buffer_manager, orders, payload_layout);
 	global_sort->external = external;
 
+	//	Set up a comparator for the partition subset
 	partition_layout = global_sort->sort_layout.GetPrefixComparisonLayout(partitions.size());
 }
 
+int PartitionGlobalHashGroup::ComparePartitions(const SBIterator &left, const SBIterator &right) const {
+	int part_cmp = 0;
+	if (partition_layout.all_constant) {
+		part_cmp = FastMemcmp(left.entry_ptr, right.entry_ptr, partition_layout.comparison_size);
+	} else {
+		part_cmp = Comparators::CompareTuple(left.scan, right.scan, left.entry_ptr, right.entry_ptr, partition_layout,
+		                                     left.external);
+	}
+	return part_cmp;
+}
+
 void PartitionGlobalHashGroup::ComputeMasks(ValidityMask &partition_mask, ValidityMask &order_mask) {
 	D_ASSERT(count > 0);
 
-	//	Set up a comparator for the partition subset
-	const auto partition_size = partition_layout.comparison_size;
-
 	SBIterator prev(*global_sort, ExpressionType::COMPARE_LESSTHAN);
 	SBIterator curr(*global_sort, ExpressionType::COMPARE_LESSTHAN);
 
@@ -34,13 +43,8 @@ void PartitionGlobalHashGroup::ComputeMasks(ValidityMask &partition_mask, Validi
 	order_mask.SetValidUnsafe(0);
 	for (++curr; curr.GetIndex() < count; ++curr) {
 		//	Compare the partition subset first because if that differs, then so does the full ordering
-		int part_cmp = 0;
-		if (partition_layout.all_constant) {
-			part_cmp = FastMemcmp(prev.entry_ptr, curr.entry_ptr, partition_size);
-		} else {
-			part_cmp = Comparators::CompareTuple(prev.scan, curr.scan, prev.entry_ptr, curr.entry_ptr, partition_layout,
-			                                     prev.external);
-		}
+		const auto part_cmp = ComparePartitions(prev, curr);
+		;
 
 		if (part_cmp) {
 			partition_mask.SetValidUnsafe(curr.GetIndex());
@@ -52,31 +56,40 @@ void PartitionGlobalHashGroup::ComputeMasks(ValidityMask &partition_mask, Validi
 	}
 }
 
-PartitionGlobalSinkState::PartitionGlobalSinkState(ClientContext &context,
-                                                   const vector<unique_ptr<Expression>> &partitions_p,
-                                                   const vector<BoundOrderByNode> &orders_p, const Types &payload_types,
-                                                   const vector<unique_ptr<BaseStatistics>> &partitions_stats,
-                                                   idx_t estimated_cardinality)
-    : context(context), buffer_manager(BufferManager::GetBufferManager(context)), allocator(Allocator::Get(context)),
-      payload_types(payload_types), memory_per_thread(0), count(0) {
+void PartitionGlobalSinkState::GenerateOrderings(Orders &partitions, Orders &orders,
+                                                 const vector<unique_ptr<Expression>> &partition_bys,
+                                                 const Orders &order_bys,
+                                                 const vector<unique_ptr<BaseStatistics>> &partition_stats) {
 
 	// we sort by both 1) partition by expression list and 2) order by expressions
-	const auto partition_cols = partitions_p.size();
+	const auto partition_cols = partition_bys.size();
 	for (idx_t prt_idx = 0; prt_idx < partition_cols; prt_idx++) {
-		auto &pexpr = partitions_p[prt_idx];
+		auto &pexpr = partition_bys[prt_idx];
 
-		if (partitions_stats.empty() || !partitions_stats[prt_idx]) {
+		if (partition_stats.empty() || !partition_stats[prt_idx]) {
 			orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, pexpr->Copy(), nullptr);
 		} else {
 			orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, pexpr->Copy(),
-			                    partitions_stats[prt_idx]->ToUnique());
+			                    partition_stats[prt_idx]->ToUnique());
 		}
 		partitions.emplace_back(orders.back().Copy());
 	}
 
-	for (const auto &order : orders_p) {
+	for (const auto &order : order_bys) {
 		orders.emplace_back(order.Copy());
 	}
+}
+
+PartitionGlobalSinkState::PartitionGlobalSinkState(ClientContext &context,
+                                                   const vector<unique_ptr<Expression>> &partition_bys,
+                                                   const vector<BoundOrderByNode> &order_bys,
+                                                   const Types &payload_types,
+                                                   const vector<unique_ptr<BaseStatistics>> &partition_stats,
+                                                   idx_t estimated_cardinality)
+    : context(context), buffer_manager(BufferManager::GetBufferManager(context)), allocator(Allocator::Get(context)),
+      payload_types(payload_types), memory_per_thread(0), count(0) {
+
+	GenerateOrderings(partitions, orders, partition_bys, order_bys, partition_stats);
 
 	memory_per_thread = PhysicalOperator::GetMaxThreadMemory(context);
 	external = ClientConfig::GetConfig(context).force_external;
@@ -337,7 +350,8 @@ void PartitionLocalSinkState::Combine() {
 	gstate.CombineLocalPartition(local_partition, local_append);
 }
 
-PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &sink, GroupDataPtr group_data)
+PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &sink, GroupDataPtr group_data,
+                                                     hash_t hash_bin)
     : sink(sink), group_data(std::move(group_data)), stage(PartitionSortStage::INIT), total_tasks(0), tasks_assigned(0),
       tasks_completed(0) {
 
@@ -348,6 +362,8 @@ PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &s
 
 	hash_group = sink.hash_groups[group_idx].get();
 	global_sort = sink.hash_groups[group_idx]->global_sort.get();
+
+	sink.bin_groups[hash_bin] = group_idx;
 }
 
 void PartitionLocalMergeState::Prepare() {
@@ -445,10 +461,13 @@ bool PartitionGlobalMergeState::TryPrepareNextStage() {
 
 PartitionGlobalMergeStates::PartitionGlobalMergeStates(PartitionGlobalSinkState &sink) {
 	// Schedule all the sorts for maximum thread utilisation
-	for (auto &group_data : sink.grouping_data->GetPartitions()) {
+	auto &partitions = sink.grouping_data->GetPartitions();
+	sink.bin_groups.resize(partitions.size(), partitions.size());
+	for (hash_t hash_bin = 0; hash_bin < partitions.size(); ++hash_bin) {
+		auto &group_data = partitions[hash_bin];
 		// Prepare for merge sort phase
 		if (group_data->Count()) {
-			auto state = make_uniq<PartitionGlobalMergeState>(sink, std::move(group_data));
+			auto state = make_uniq<PartitionGlobalMergeState>(sink, std::move(group_data), hash_bin);
 			states.emplace_back(std::move(state));
 		}
 	}
@@ -542,103 +561,4 @@ void PartitionMergeEvent::Schedule() {
 	SetTasks(std::move(merge_tasks));
 }
 
-PartitionLocalSourceState::PartitionLocalSourceState(PartitionGlobalSinkState &gstate_p) : gstate(gstate_p) {
-	const auto &input_types = gstate.payload_types;
-	layout.Initialize(input_types);
-	input_chunk.Initialize(gstate.allocator, input_types);
-}
-
-void PartitionLocalSourceState::MaterializeSortedData() {
-	auto &global_sort_state = *hash_group->global_sort;
-	if (global_sort_state.sorted_blocks.empty()) {
-		return;
-	}
-
-	// scan the sorted row data
-	D_ASSERT(global_sort_state.sorted_blocks.size() == 1);
-	auto &sb = *global_sort_state.sorted_blocks[0];
-
-	// Free up some memory before allocating more
-	sb.radix_sorting_data.clear();
-	sb.blob_sorting_data = nullptr;
-
-	// Move the sorting row blocks into our RDCs
-	auto &buffer_manager = global_sort_state.buffer_manager;
-	auto &sd = *sb.payload_data;
-
-	// Data blocks are required
-	D_ASSERT(!sd.data_blocks.empty());
-	auto &block = sd.data_blocks[0];
-	rows = make_uniq<RowDataCollection>(buffer_manager, block->capacity, block->entry_size);
-	rows->blocks = std::move(sd.data_blocks);
-	rows->count = std::accumulate(rows->blocks.begin(), rows->blocks.end(), idx_t(0),
-	                              [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
-
-	// Heap blocks are optional, but we want both for iteration.
-	if (!sd.heap_blocks.empty()) {
-		auto &block = sd.heap_blocks[0];
-		heap = make_uniq<RowDataCollection>(buffer_manager, block->capacity, block->entry_size);
-		heap->blocks = std::move(sd.heap_blocks);
-		hash_group.reset();
-	} else {
-		heap = make_uniq<RowDataCollection>(buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1, true);
-	}
-	heap->count = std::accumulate(heap->blocks.begin(), heap->blocks.end(), idx_t(0),
-	                              [&](idx_t c, const unique_ptr<RowDataBlock> &b) { return c + b->count; });
-}
-
-idx_t PartitionLocalSourceState::GeneratePartition(const idx_t hash_bin_p) {
-	//	Get rid of any stale data
-	hash_bin = hash_bin_p;
-
-	// There are three types of partitions:
-	// 1. No partition (no sorting)
-	// 2. One partition (sorting, but no hashing)
-	// 3. Multiple partitions (sorting and hashing)
-
-	//	How big is the partition?
-	idx_t count = 0;
-	if (hash_bin < gstate.hash_groups.size() && gstate.hash_groups[hash_bin]) {
-		count = gstate.hash_groups[hash_bin]->count;
-	} else if (gstate.rows && !hash_bin) {
-		count = gstate.count;
-	} else {
-		return count;
-	}
-
-	//	Initialise masks to false
-	const auto bit_count = ValidityMask::ValidityMaskSize(count);
-	partition_bits.clear();
-	partition_bits.resize(bit_count, 0);
-	partition_mask.Initialize(partition_bits.data());
-
-	order_bits.clear();
-	order_bits.resize(bit_count, 0);
-	order_mask.Initialize(order_bits.data());
-
-	// Scan the sorted data into new Collections
-	auto external = gstate.external;
-	if (gstate.rows && !hash_bin) {
-		// Simple mask
-		partition_mask.SetValidUnsafe(0);
-		order_mask.SetValidUnsafe(0);
-		//	No partition - align the heap blocks with the row blocks
-		rows = gstate.rows->CloneEmpty(gstate.rows->keep_pinned);
-		heap = gstate.strings->CloneEmpty(gstate.strings->keep_pinned);
-		RowDataCollectionScanner::AlignHeapBlocks(*rows, *heap, *gstate.rows, *gstate.strings, layout);
-		external = true;
-	} else if (hash_bin < gstate.hash_groups.size() && gstate.hash_groups[hash_bin]) {
-		// Overwrite the collections with the sorted data
-		hash_group = std::move(gstate.hash_groups[hash_bin]);
-		hash_group->ComputeMasks(partition_mask, order_mask);
-		MaterializeSortedData();
-	} else {
-		return count;
-	}
-
-	scanner = make_uniq<RowDataCollectionScanner>(*rows, *heap, layout, external, false);
-
-	return count;
-}
-
 } // namespace duckdb

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

@@ -367,7 +367,7 @@ int SBIterator::ComparisonValue(ExpressionType comparison) {
 }
 
 static idx_t GetBlockCountWithEmptyCheck(const GlobalSortState &gss) {
-	D_ASSERT(gss.sorted_blocks.size() > 0);
+	D_ASSERT(!gss.sorted_blocks.empty());
 	return gss.sorted_blocks[0]->radix_sorting_data.size();
 }
 

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) {