GH-44246: [JS] Add a lightweight array view to Table

js/perf/index.ts

@@ -205,6 +205,10 @@ for (const { name, table, counts } of config) {
             table.toArray();
         }),
 
+        b.add(`toArrayView, dataset: ${name}, numRows: ${formatNumber(table.numRows)}`, () => {
+            table.toArrayView();
+        }),
+
         b.add(`get, dataset: ${name}, numRows: ${formatNumber(table.numRows)}`, () => {
             for (let i = -1, n = table.numRows; ++i < n;) {
                 table.get(i);

js/src/row/struct.ts

@@ -39,7 +39,7 @@ export class StructRow<T extends TypeMap = any> {
     constructor(parent: Data<Struct<T>>, rowIndex: number) {
         this[kParent] = parent;
         this[kRowIndex] = rowIndex;
-        return new Proxy(this, new StructRowProxyHandler());
+        return new Proxy(this, structRowProxyHandler);
     }
 
     public toArray() { return Object.values(this.toJSON()); }
@@ -157,3 +157,5 @@ class StructRowProxyHandler<T extends TypeMap = any> implements ProxyHandler<Str
         return false;
     }
 }
+
+const structRowProxyHandler = new StructRowProxyHandler();

js/src/table.ts

@@ -238,17 +238,30 @@ export class Table<T extends TypeMap = any> {
      *
      * @returns An Array of Table rows.
      */
-    public toArray() {
+    public toArray(): Array<Struct<T>['TValue']> {
         return [...this];
     }
 
+    /**
+     * Return a JavaScript Array view of the Table rows.
+     *
+     * It is a lightweight read-only proxy that delegates to the table. Accessing elements has some
+     * overhead compared to the regular array returned by `toArray()` because of this indirection,
+     * but it avoids potentially large memory allocation.
+     *
+     * @returns An Array proxy to the Table rows.
+     */
+    public toArrayView(): Array<Struct<T>['TValue']> {
+        return new Proxy([] as Array<Struct<T>['TValue']>, new TableArrayProxyHandler(this));
+    }
+
     /**
      * Returns a string representation of the Table rows.
      *
      * @returns A string representation of the Table rows.
      */
     public toString() {
-        return `[\n  ${this.toArray().join(',\n  ')}\n]`;
+        return `[\n  ${this.toArrayView().join(',\n  ')}\n]`;
     }
 
     /**
@@ -444,3 +457,77 @@ export function tableFromArrays<I extends Record<string | number | symbol, Typed
     }
     return new Table<T>(vecs);
 }
+
+class TableArrayProxyHandler<T extends TypeMap = any> implements ProxyHandler<Array<Struct<T>['TValue']>> {
+    table: Table<T>;
+
+    constructor(table: Table<T>) {
+        this.table = table;
+    }
+
+    // Traps that aren't implemented:
+    // - apply
+    // - construct
+    // - defineProperty
+    // - deleteProperty
+    // - getPrototypeOf
+    // - isExtensible
+    // - preventExtensions
+    // - set
+    // - setPrototypeOf
+
+    get(target: Array<Struct<T>['TValue']>, p: string | symbol, receiver: any): any {
+        if (typeof p === 'string') {
+            const i = Number(p);
+            if (Number.isInteger(i)) {
+                return this.table.get(i);
+            }
+            if (p === 'at') {
+                return (i: number): Struct<T>['TValue'] | undefined => {
+                    return this.table.at(i) ?? undefined;
+                };
+            }
+            if (p === 'length') {
+                return this.table.numRows;
+            }
+        } else if (p === Symbol('keys')) {
+            const end = this.table.numRows;
+            return function * () {
+                let i = 0;
+                while(i < end) {
+                    yield i++;
+                }
+                return;
+            };
+        }
+        return Reflect.get(target, p, receiver);
+    }
+
+    getOwnPropertyDescriptor(target: Array<Struct<T>['TValue']>, p: string | symbol): PropertyDescriptor | undefined {
+        if (typeof p === 'string') {
+            const i = Number(p);
+            if (Number.isInteger(i) && i >= 0 && i < this.table.numRows) {
+                return { enumerable: true, configurable: true };
+            }
+        }
+        return Reflect.getOwnPropertyDescriptor(target, p);
+    }
+
+    has(target: Array<Struct<T>['TValue']>, p: string | symbol): boolean {
+        if (typeof p === 'string') {
+            const i = Number(p);
+            if (Number.isInteger(i)) {
+                return i >= 0 && i < this.table.numRows;
+            }
+        }
+        return Reflect.has(target, p);
+    }
+
+    ownKeys(_target: Array<Struct<T>['TValue']>): ArrayLike<string | symbol> {
+        // Can be expensive as we allocate an array with all index numbers as strings
+        const keys = Array.from({length: this.table.numRows}, (_, i) => String(i));
+        keys.push('length');
+        return keys;
+    }
+}
+

js/test/unit/table/table-test.ts

@@ -79,3 +79,61 @@ describe('tableFromJSON()', () => {
         expect(table.getChild('c')!.type).toBeInstanceOf(Dictionary);
     });
 });
+
+describe('table views', () => {
+    const table = tableFromJSON([{
+        a: 42,
+        b: true,
+        c: 'foo',
+    }, {
+        a: 12,
+        b: false,
+        c: 'bar',
+    }]);
+
+    function checkArrayValues(arr: Array<any>) {
+        expect(arr).toHaveLength(2);
+        expect(arr[0].a).toBe(42);
+        expect(arr[0].b).toBe(true);
+        expect(arr[0].c).toBe('foo');
+        expect(arr[1].a).toBe(12);
+        expect(arr[1].b).toBe(false);
+        expect(arr[1].c).toBe('bar');
+    }
+
+    function checkArray(arr: Array<any>) {
+        test('Wrapper', () => checkArrayValues(arr));
+
+        test('Iterator', () => {
+            const arr2 = [];
+            for (let item of arr) {
+                arr2.push(item);
+            }
+            checkArrayValues(arr);
+        });
+
+        test('Array index', () => {
+            const arr2 = new Array(arr.length);
+            for (let i = 0; i < arr2.length; i++) {
+                arr2[i] = arr[i];
+            }
+            checkArrayValues(arr2);
+        });
+
+        test('Keys', () => {
+            const arr2: any[] = new Array(arr.length);
+            let keys = Object.keys(arr);
+            for (let k in keys) {
+                arr2[k] = arr[k];
+            }
+            checkArrayValues(arr2);
+        });
+    }
+
+    describe('table.toArray()', () => {
+        checkArray(table.toArray());
+    });
+    describe('table.toArrayView()', () => {
+        checkArray(table.toArrayView());
+    });
+});