test(arrow-select): add take_bytes coverage for sliced values and nullable offset overflow

Adds two tests to `take_bytes`:

- `test_take_bytes_sliced_values`: takes from a byte array that has been
  sliced so its value offsets no longer start at zero, covering both the
  no-null fast path and the nullable path (null indices and selected null
  values).
- `test_take_bytes_offset_overflow_nullable`: verifies the
  `OffsetOverflowError` is also produced on the nullable code path, not
  only the no-null fast path.

Both pass on the current implementation.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: alamb

arrow-select/src/take.rs

@@ -1728,6 +1728,41 @@ mod tests {
         assert_eq!(result.as_ref(), &expected);
     }
 
+    /// Take from a *sliced* byte array, i.e. one whose value offsets do not
+    /// start at zero. This exercises copying byte data out of an array with a
+    /// non-zero base offset for both the no-null fast path and the nullable
+    /// path (null indices and selected null values).
+    #[test]
+    fn test_take_bytes_sliced_values() {
+        let values = StringArray::from(vec![
+            Some("aaa"),
+            Some("bbb"),
+            None,
+            Some("ccccc"),
+            Some("dd"),
+            None,
+            Some("eeee"),
+        ]);
+        // Slice so the underlying value offsets no longer start at 0:
+        // sliced == [None, "ccccc", "dd", None, "eeee"]
+        let sliced = values.slice(2, 5);
+
+        // Fast path: every output slot is valid (no null indices, no null
+        // values selected).
+        let indices = Int32Array::from(vec![1, 2, 4, 1]);
+        let result = take(&sliced, &indices, None).unwrap();
+        let expected =
+            StringArray::from(vec![Some("ccccc"), Some("dd"), Some("eeee"), Some("ccccc")]);
+        assert_eq!(result.as_string::<i32>(), &expected);
+
+        // Nullable path: a null index (position 1) and selected null values
+        // (sliced indices 0 and 3 are null).
+        let indices = Int32Array::from(vec![Some(1), None, Some(0), Some(4), Some(3)]);
+        let result = take(&sliced, &indices, None).unwrap();
+        let expected = StringArray::from(vec![Some("ccccc"), None, None, Some("eeee"), None]);
+        assert_eq!(result.as_string::<i32>(), &expected);
+    }
+
     fn _test_byte_view<T>()
     where
         T: ByteViewType,
@@ -2819,6 +2854,28 @@ mod tests {
         ));
     }
 
+    /// The offset-overflow error must also be produced on the nullable code
+    /// path (when the output contains nulls), not only on the no-null fast path.
+    #[test]
+    fn test_take_bytes_offset_overflow_nullable() {
+        // A single large value selected enough times to overflow an i32 offset,
+        // which keeps the index array small. One null index forces the output
+        // to contain nulls and therefore exercises the nullable code path.
+        let value_len = 100_000;
+        let big = "a".repeat(value_len);
+        let values = StringArray::from(vec![Some(big.as_str())]);
+
+        let n = i32::MAX as usize / value_len + 2;
+        let validity =
+            NullBuffer::from_iter(std::iter::once(false).chain(std::iter::repeat_n(true, n)));
+        let indices = Int32Array::new(vec![0i32; n + 1].into(), Some(validity));
+
+        assert!(matches!(
+            take(&values, &indices, None),
+            Err(ArrowError::OffsetOverflowError(_))
+        ));
+    }
+
     #[test]
     fn test_take_run_empty_indices() {
         let mut builder = PrimitiveRunBuilder::<Int32Type, Int32Type>::new();