reduce mixing of span iterators

Author: taepper

cpp/src/arrow/compute/kernels/vector_array_sort.cc

@@ -79,16 +79,16 @@ struct PartitionNthToIndices {
     }
     const auto p = PartitionNullsAndNans<ArrayType, NonStablePartitioner>(
         out_span, arr, 0, options.null_placement);
-    auto nth_begin = out_span.begin() + pivot;
-    if (nth_begin >= p.non_null_like_range.begin() &&
-        nth_begin < p.non_null_like_range.end()) {
-      std::ranges::nth_element(
-          p.non_null_like_range.begin(), nth_begin, p.non_null_like_range.end(),
-          [&arr](uint64_t left, uint64_t right) {
-            const auto lval = GetView::LogicalValue(arr.GetView(left));
-            const auto rval = GetView::LogicalValue(arr.GetView(right));
-            return lval < rval;
-          });
+    auto nth_begin = out_span.data() + pivot;
+    auto non_null_begin = p.non_null_like_range.data();
+    auto non_null_end = p.non_null_like_range.data() + p.non_null_like_range.size();
+    if (nth_begin >= non_null_begin && nth_begin < non_null_end) {
+      std::nth_element(non_null_begin, nth_begin, non_null_end,
+                       [&arr](uint64_t left, uint64_t right) {
+                         const auto lval = GetView::LogicalValue(arr.GetView(left));
+                         const auto rval = GetView::LogicalValue(arr.GetView(right));
+                         return lval < rval;
+                       });
     }
     return Status::OK();
   }
@@ -156,16 +156,14 @@ class ArrayCompareSorter {
         indices, values, offset, options.null_placement);
     if (options.order == SortOrder::Ascending) {
       std::ranges::stable_sort(
-          p.non_null_like_range,
-          [&values, &offset](uint64_t left, uint64_t right) {
+          p.non_null_like_range, [&values, &offset](uint64_t left, uint64_t right) {
             const auto lhs = GetView::LogicalValue(values.GetView(left - offset));
             const auto rhs = GetView::LogicalValue(values.GetView(right - offset));
             return lhs < rhs;
           });
     } else {
       std::ranges::stable_sort(
-          p.non_null_like_range,
-          [&values, &offset](uint64_t left, uint64_t right) {
+          p.non_null_like_range, [&values, &offset](uint64_t left, uint64_t right) {
             const auto lhs = GetView::LogicalValue(values.GetView(left - offset));
             const auto rhs = GetView::LogicalValue(values.GetView(right - offset));
             // We don't use 'left > right' here to reduce required operator.

cpp/src/arrow/compute/kernels/vector_sort_internal.h

@@ -320,14 +320,14 @@ struct ChunkedMergeImpl {
 
     // Mutate the input, stably in two steps, to obtain the following layouts:
     // [left nul .. left nan .. right nul .. right nan .. left non-nul .. right non-nus]
-    std::rotate(left.non_null_like_range.begin(), right.null_range.begin(),
-                right.nan_range.end());
+    std::rotate(left.non_null_like_range.data(), right.null_range.data(),
+                right.nan_range.data() + right.nan_range.size());
 
     // only use sizes of ranges that are at a different position now
     // [left nul .. right nul .. left nan .. right nan .. left non-nulls .. right
     // non-nulls] this is a no-op if no nan values are present
-    std::rotate(left.nan_range.begin(), left.nan_range.begin() + left.nan_range.size(),
-                left.nan_range.begin() + left.nan_range.size() + right.null_range.size());
+    std::rotate(left.nan_range.data(), left.nan_range.data() + left.nan_range.size(),
+                left.nan_range.data() + left.nan_range.size() + right.null_range.size());
 
     std::span<CompressedChunkLocation> full_span{left.overall_begin(),
                                                  right.overall_end()};
@@ -366,14 +366,14 @@ struct ChunkedMergeImpl {
 
     // Mutate the input, stably in two steps, to obtain the following layouts:
     // [left non-nul .. right non-nul .. left nan .. left nul .. right nan .. right nul]
-    std::rotate(left.nan_range.begin(), right.non_null_like_range.begin(),
-                right.non_null_like_range.end());
+    std::rotate(left.nan_range.data(), right.non_null_like_range.data(),
+                right.non_null_like_range.data() + right.non_null_like_range.size());
 
     // only use sizes of ranges that are at a different position now
     // [left non-nul .. right non-nul .. left nan .. left nul .. right nan .. right nul]
     // this is a no-op if no nan values are present
     auto new_left_null_range_begin =
-        left.non_null_like_range.begin() + left.non_null_like_range.size() +
+        left.non_null_like_range.data() + left.non_null_like_range.size() +
         right.non_null_like_range.size() + left.nan_range.size();
     std::rotate(
         new_left_null_range_begin, new_left_null_range_begin + left.null_range.size(),