fix(utils): support union types in empty_batch

pyarrow's ``pa.array([], type=union)`` raises ArrowNotImplementedError, so
``empty_batch`` failed for any schema containing a union field.  Build empty
union arrays via ``Array.from_buffers`` from empty children + an empty
type-codes buffer (plus an empty offsets buffer for dense unions).

Adds tests covering both sparse and dense union schemas.

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

Author: rustyconover

tests/test_utils.py

@@ -671,6 +671,22 @@ def test_empty_batch_column_types(self) -> None:
         assert batch.column("flag").type == pa.bool_()
         assert batch.column("data").type == pa.binary()
 
+    def test_empty_batch_sparse_union(self) -> None:
+        """Sparse union schemas — pa.array([], type=union) raises, so empty_batch must take a different path."""
+        union_type = pa.sparse_union([pa.field("i", pa.int32()), pa.field("s", pa.string())], type_codes=[0, 1])
+        schema = pa.schema([pa.field("u", union_type), pa.field("x", pa.int64())])
+        batch = empty_batch(schema)
+        assert batch.num_rows == 0
+        assert batch.schema.equals(schema)
+
+    def test_empty_batch_dense_union(self) -> None:
+        """Dense union schemas — same restriction as sparse, plus an extra offsets buffer."""
+        union_type = pa.dense_union([pa.field("i", pa.int32()), pa.field("s", pa.string())], type_codes=[0, 1])
+        schema = pa.schema([pa.field("u", union_type)])
+        batch = empty_batch(schema)
+        assert batch.num_rows == 0
+        assert batch.schema.equals(schema)
+
 
 # ---------------------------------------------------------------------------
 # TestSerializeDeserializeRecordBatch

vgi_rpc/utils.py

@@ -167,11 +167,34 @@ def __exit__(
 def empty_batch(schema: pa.Schema) -> pa.RecordBatch:
     """Return an empty batch conforming to the schema."""
     return pa.RecordBatch.from_arrays(
-        [pa.array([], type=field.type) for field in schema],
+        [_empty_array(field.type) for field in schema],
         schema=schema,
     )
 
 
+def _empty_array(arrow_type: pa.DataType) -> "pa.Array[Any]":
+    """Build a zero-length array of ``arrow_type``.
+
+    pyarrow's ``pa.array([], type=...)`` constructor doesn't support
+    union types — it raises ``ArrowNotImplementedError``. Build those
+    via ``Array.from_buffers`` from empty children + an empty type-codes
+    buffer (plus an empty offsets buffer for dense unions).
+    """
+    if pa.types.is_union(arrow_type):
+        union_type = cast(pa.UnionType, arrow_type)
+        children = [pa.array([], type=field.type) for field in union_type]
+        # buffers()[1] is the data buffer; for an empty primitive array it's
+        # always present, but the type stub says Buffer | None. The leading
+        # None stands in for the validity bitmap that union arrays don't
+        # carry (nulls live in the children).
+        type_codes_buf = cast(pa.Buffer, pa.array([], type=pa.int8()).buffers()[1])
+        buffers: list[pa.Buffer | None] = [None, type_codes_buf]
+        if union_type.mode == "dense":
+            buffers.append(cast(pa.Buffer, pa.array([], type=pa.int32()).buffers()[1]))
+        return pa.Array.from_buffers(arrow_type, 0, cast(list[pa.Buffer], buffers), children=children)
+    return pa.array([], type=arrow_type)
+
+
 def serialize_record_batch(
     destination: IOBase,
     batch: pa.RecordBatch,