MINOR: Reject non zero offset on array import (#1263)

## What's Changed

Instead of silently accepting the array and pretending the import went
fine reject arrays where offset is non 0. Add mention to the docs that
this is not supported

This is documentation and negative case for #251

---------

Signed-off-by: Robert Kruszewski <github@robertk.io>
Co-authored-by: JB Onofré <jb.onofre@dremio.com>

Author: robert3005

c/src/main/java/org/apache/arrow/c/ArrayImporter.java

@@ -30,6 +30,7 @@
 import org.apache.arrow.vector.dictionary.Dictionary;
 import org.apache.arrow.vector.dictionary.DictionaryProvider;
 import org.apache.arrow.vector.ipc.message.ArrowFieldNode;
+import org.apache.arrow.vector.types.pojo.ArrowType;
 import org.apache.arrow.vector.types.pojo.DictionaryEncoding;
 
 /** Importer for {@link ArrowArray}. */
@@ -83,6 +84,15 @@ private void importChild(ArrayImporter parent, ArrowArray src) {
   }
 
   private void doImport(ArrowArray.Snapshot snapshot) {
+    // A non-zero offset is only meaningful for arrays that have buffers to offset into.
+    // Null arrays carry no buffers, so their offset is inert and safe to ignore.
+    checkState(
+        snapshot.offset == 0
+            || snapshot.length == 0
+            || vector.getField().getType().getTypeID() == ArrowType.ArrowTypeID.Null,
+        "ArrowArray struct has non-zero offset (%s), which is not supported",
+        snapshot.offset);
+
     // First import children (required for reconstituting parent array data)
     long[] children =
         NativeUtil.toJavaArray(snapshot.children, checkedCastToInt(snapshot.n_children));

c/src/main/java/org/apache/arrow/c/Data.java

@@ -35,7 +35,8 @@
 /**
  * Functions for working with the C data interface.
  *
- * <p>This API is EXPERIMENTAL. Note that currently only 64bit systems are supported.
+ * <p>This API is EXPERIMENTAL. Note that currently only 64bit systems are supported. Importing
+ * {@link ArrowArray ArrowArrays} with a non-zero offset is not supported.
  */
 public final class Data {
 

c/src/test/java/org/apache/arrow/c/RoundtripTest.java

@@ -1051,6 +1051,65 @@ public void testImportReleasedArray() {
     }
   }
 
+  @Test
+  public void testImportArrayWithNonZeroOffset() {
+    try (IntVector source = new IntVector("source", allocator);
+        IntVector destination = new IntVector("destination", allocator);
+        ArrowArray array = ArrowArray.allocateNew(allocator)) {
+      setVector(source, 1, 2, 3);
+      Data.exportVector(allocator, source, null, array);
+
+      ArrowArray.Snapshot snapshot = array.snapshot();
+      snapshot.offset = 1;
+      array.save(snapshot);
+
+      Exception e =
+          assertThrows(
+              IllegalStateException.class,
+              () -> Data.importIntoVector(allocator, array, destination, null));
+      assertEquals(
+          "ArrowArray struct has non-zero offset (1), which is not supported", e.getMessage());
+    }
+  }
+
+  @Test
+  public void testImportEmptyArrayWithNonZeroOffset() {
+    try (IntVector source = new IntVector("source", allocator);
+        IntVector destination = new IntVector("destination", allocator);
+        ArrowArray array = ArrowArray.allocateNew(allocator)) {
+      setVector(source, 1, 2, 3);
+      Data.exportVector(allocator, source, null, array);
+
+      ArrowArray.Snapshot snapshot = array.snapshot();
+      snapshot.offset = source.getValueCount();
+      snapshot.length = 0;
+      array.save(snapshot);
+
+      Data.importIntoVector(allocator, array, destination, null);
+      assertEquals(0, destination.getValueCount());
+    }
+  }
+
+  @Test
+  public void testImportNullArrayWithNonZeroOffset() {
+    try (NullVector source = new NullVector("source", 10);
+        NullVector destination = new NullVector("destination");
+        ArrowArray array = ArrowArray.allocateNew(allocator)) {
+      Data.exportVector(allocator, source, null, array);
+
+      // Mimic a sliced null array. Arrow C++ propagates the slice offset onto the struct
+      // even for null arrays, which export no buffers at all (n_buffers == 0), so there is
+      // nothing for the offset to apply to and the import is safe.
+      ArrowArray.Snapshot snapshot = array.snapshot();
+      snapshot.offset = 2;
+      snapshot.length = 8;
+      array.save(snapshot);
+
+      Data.importIntoVector(allocator, array, destination, null);
+      assertEquals(8, destination.getValueCount());
+    }
+  }
+
   @Test
   public void testArrayStructReuse() {
     // Consumer allocates empty structures

docs/source/cdata.rst

@@ -22,6 +22,11 @@ C Data Interface
 Arrow supports exchanging data without copying or serialization within the same process
 through :external+arrow:ref:`c-data-interface`, even between different language runtimes.
 
+.. note::
+
+   The Arrow Java C Data Interface implementation does not support importing arrays with
+   a non-zero offset.
+
 Java to Python
 --------------