fix: Preserve numRows for zero-column RecordBatch in IPC

When a zero-column RecordBatch is deserialized from IPC,
ensureSameLengthData in the RecordBatch constructor recomputes length
from children via chunks.reduce((max, col) => Math.max(max, col.length), 0).
With zero children, this always returns 0 — discarding the original
length from the IPC message header.

Pass this.data.length to ensureSameLengthData as the explicit maxLength
parameter, which the function already accepts as an optional third
argument. For batches with columns, this.data.length already matches
the max column length, so there is no behavior change.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: rustyconover

src/recordbatch.ts

@@ -81,7 +81,7 @@ export class RecordBatch<T extends TypeMap = any> {
                 if (!(this.data instanceof Data)) {
                     throw new TypeError('RecordBatch constructor expects a [Schema, Data] pair.');
                 }
-                [this.schema, this.data] = ensureSameLengthData<T>(this.schema, this.data.children as Data<T[keyof T]>[]);
+                [this.schema, this.data] = ensureSameLengthData<T>(this.schema, this.data.children as Data<T[keyof T]>[], this.data.length);
                 break;
             }
             case 1: {

test/data/generate_zero_column_batch.py

@@ -0,0 +1,36 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""Generate a zero-column IPC stream with 100 rows for testing."""
+
+import pyarrow as pa
+import pyarrow.ipc as ipc
+
+# Create a zero-column RecordBatch with 100 rows by creating a batch
+# with a dummy column and then dropping it.
+schema_with_col = pa.schema([("_dummy", pa.int32())])
+batch_with_col = pa.RecordBatch.from_arrays(
+    [pa.array([0] * 100, type=pa.int32())], schema=schema_with_col
+)
+batch = batch_with_col.drop_columns(["_dummy"])
+assert batch.num_rows == 100
+assert batch.num_columns == 0
+
+with open("zero_column_batch.arrow", "wb") as f:
+    writer = ipc.new_stream(f, batch.schema)
+    writer.write_batch(batch)
+    writer.close()

test/data/zero_column_batch.arrow

@@ -0,0 +1,90 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+import '../../../jest-extensions.js';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import {
+    makeData,
+    RecordBatch,
+    RecordBatchStreamWriter,
+    Schema,
+    Struct,
+    tableFromIPC,
+} from 'apache-arrow';
+
+const testDataDir = path.resolve(process.cwd(), 'test/data');
+
+describe('Zero-column RecordBatch numRows preservation', () => {
+
+    describe('PyArrow interop', () => {
+
+        test('should read PyArrow zero-column stream and preserve numRows', () => {
+            const buffer = readFileSync(path.resolve(testDataDir, 'zero_column_batch.arrow'));
+            const table = tableFromIPC(buffer);
+
+            expect(table.numRows).toBe(100);
+            expect(table.numCols).toBe(0);
+            expect(table.batches).toHaveLength(1);
+            expect(table.batches[0].numRows).toBe(100);
+        });
+    });
+
+    describe('JS round-trip', () => {
+
+        test('zero-column batch should round-trip through IPC stream writer', () => {
+            const schema = new Schema([]);
+            const data = makeData({
+                type: new Struct([]),
+                length: 100,
+                nullCount: 0,
+                children: [],
+            });
+            const batch = new RecordBatch(schema, data);
+            expect(batch.numRows).toBe(100);
+            expect(batch.numCols).toBe(0);
+
+            const writer = new RecordBatchStreamWriter();
+            writer.write(batch);
+            writer.finish();
+            const buffer = writer.toUint8Array(true);
+
+            const table = tableFromIPC(buffer);
+            expect(table.numRows).toBe(100);
+            expect(table.numCols).toBe(0);
+            expect(table.batches).toHaveLength(1);
+            expect(table.batches[0].numRows).toBe(100);
+        });
+    });
+
+    describe('Direct constructor', () => {
+
+        test('RecordBatch constructor preserves length for zero-column data', () => {
+            const schema = new Schema([]);
+            const data = makeData({
+                type: new Struct([]),
+                length: 100,
+                nullCount: 0,
+                children: [],
+            });
+            const batch = new RecordBatch(schema, data);
+
+            expect(batch.numRows).toBe(100);
+            expect(batch.numCols).toBe(0);
+        });
+    });
+});