add test and address review comments

Author: scott-routledge2

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

@@ -29,6 +29,7 @@
 #include "arrow/result.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
+#include "arrow/util/bit_util.h"
 #include "arrow/util/formatting.h"
 #include "arrow/util/int_util.h"
 #include "arrow/util/logging_internal.h"
@@ -305,23 +306,33 @@ BinaryToBinaryCastExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* ou
     }
   }
 
-  std::shared_ptr<ArrayData> input_arr = input.ToArrayData();
-  ArrayData* output = out->array_data().get();
-  output->length = input_arr->length;
-  output->SetNullCount(input_arr->null_count);
-  output->buffers = std::move(input_arr->buffers);
-  output->child_data = std::move(input_arr->child_data);
-
-  if (output->buffers[0]) {
-    // If reusing the null bitmap, ensure offset into the first byte is the same as input.
-    output->offset = input_arr->offset % 8;
-    output->buffers[0] = SliceBuffer(output->buffers[0], input_arr->offset / 8);
+  if constexpr (sizeof(typename I::offset_type) != sizeof(typename O::offset_type)) {
+    std::shared_ptr<ArrayData> input_arr = input.ToArrayData();
+    ArrayData* output = out->array_data().get();
+    output->length = input_arr->length;
+    // output->offset is set below
+    output->SetNullCount(input_arr->null_count);
+    output->buffers = std::move(input_arr->buffers);
+
+    // Slice buffers to reduce allocation when casting the offsets buffer
+    int64_t offset = input_arr->offset;
+    size_t input_offset_type_size = sizeof(typename I::offset_type);
+    if (output->null_count != 0 && output->buffers[0]) {
+      // Avoid reallocation of the validity buffer by allowing some padding bits
+      output->offset = input_arr->offset % 8;
+    } else {
+      output->offset = 0;
+    }
+    if (output->buffers[0]) {
+      output->buffers[0] = SliceBuffer(output->buffers[0], offset / 8);
+    }
+    output->buffers[1] = SliceBuffer(output->buffers[1], offset * input_offset_type_size);
+
+    return CastBinaryToBinaryOffsets<typename I::offset_type, typename O::offset_type>(
+        ctx, input, out->array_data().get());
   } else {
-    output->offset = 0;
+    return ZeroCopyCastExec(ctx, batch, out);
   }
-
-  return CastBinaryToBinaryOffsets<typename I::offset_type, typename O::offset_type>(
-      ctx, input, out->array_data().get());
 }
 
 // String View -> Offset String

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

@@ -3400,6 +3400,38 @@ TEST(Cast, StringToString) {
   }
 }
 
+TEST(Cast, StringToStringWithOffset) {
+  std::cout << " casting string offset test " << std::endl;
+  // GH-43660: Check casting String Arrays with nonzero offset
+  for (auto from_type : {utf8(), large_utf8()}) {
+    for (auto to_type : {utf8(), large_utf8()}) {
+      for (int64_t offset : {3, 8, 10, 12}) {
+        auto input_with_nulls = R"([
+          "foo", null, "bar", null, "quu", "foo", "baz", "bar",
+          null, "bar", "baz", null
+          ])";
+
+        auto input_arr_with_nulls = ArrayFromJSON(from_type, input_with_nulls);
+        auto output_arr_with_nulls = ArrayFromJSON(to_type, input_with_nulls);
+        std::cout << "from type: " << from_type->ToString() << " offset: " << offset
+                  << " to type: " << to_type->ToString() << std::endl;
+        CheckCast(input_arr_with_nulls->Slice(offset),
+                  output_arr_with_nulls->Slice(offset));
+
+        std::cout << "wout nulls " << std::endl;
+        auto input_no_nulls = R"([
+            "foo", "aa", "bar", "bb", "quu", "foo", "baz", "bar",
+            "cc", "bar", "baz", "foo"
+            ])";
+
+        auto input_arr_no_nulls = ArrayFromJSON(from_type, input_no_nulls);
+        auto output_arr_no_nulls = ArrayFromJSON(to_type, input_no_nulls);
+        CheckCast(input_arr_no_nulls->Slice(offset), output_arr_no_nulls->Slice(offset));
+      }
+    }
+  }
+}
+
 TEST(Cast, BinaryOrStringToFixedSizeBinary) {
   for (auto in_type :
        {utf8(), large_utf8(), utf8_view(), binary(), binary_view(), large_binary()}) {