test(sea): F4 round-3 — inline-result-set (SELECT 1) edge case

DA F4 round-1 M1 finding (partial): the existing 5 fetch-all e2e
cases (range(0,100) row-count, range(0,0) empty, multi-column,
drain-twice, drain-after-close) all flow through the row-set
generator path. A literal `SELECT 1` returns a single inline
batch and exercises a distinct code path inside
SeaOperationBackend.fetchChunk → ResultSlicer → ArrowResultConverter
that the other 5 do not.

One new `it()` block:
- Open session, execute `SELECT 1 AS x`, drain via `fetchAll()`.
- Assert array of length 1; row has property `x` with non-null,
  non-undefined value. Type pinning is deliberately loose so the
  test stays forward-compatible with converter promotion changes;
  the load-bearing assertion is the single-row inline-batch drain.

Drop-in form follows DA's round-3 snippet verbatim (modulo the
loosened type pin per the comment above).

Gates (touched file only):
- `node_modules/.bin/eslint tests/e2e/sea/fetch-all-e2e.test.ts`
  EXIT=0, zero errors.
- `node_modules/.bin/tsc --noEmit` baseline 21 → current 21
  (delta 0; the only error in the touched file is a pre-existing
  `import.meta` issue at line 57 carried over from the F4 round-1
  H1 fix — not touched by this commit).

Live e2e against pecotesting via `TS_NODE_TRANSPILE_ONLY=true yarn
e2e tests/e2e/sea/fetch-all-e2e.test.ts`:
  6/6 passing in 4s, with the new test landing at 445ms.

Closes the round-3 F4-M1 audit item; F3-M3 closed in 9f1a967;
matrix scope-down landed by team-lead on PR #77 (dfea75a).

Co-authored-by: Isaac
Signed-off-by: Madhavendra Rathore <madhavendra.rathore@databricks.com>

Author: msrathore-db

tests/e2e/sea/fetch-all-e2e.test.ts

@@ -258,4 +258,41 @@ describe('SEA fetchAll — Array<object> row drain', function suite() {
       await client.close();
     }
   });
+
+  it('drains a single inline result-set row (SELECT 1)', async () => {
+    // `SELECT 1` returns a single row inline, exercising the
+    // small-batch code path the other tests don't hit. `range(0, n)`
+    // queries go through the row-set generator; `range(0, 0)` is
+    // the empty branch. A literal scalar pin-points the inline-batch
+    // path inside SeaOperationBackend.fetchChunk → ResultSlicer →
+    // ArrowResultConverter, which is otherwise untested here.
+    const client = await connect();
+    try {
+      const session = await client.openSession();
+      try {
+        const operation = await session.executeStatement('SELECT 1 AS x');
+        try {
+          const rows = await operation.fetchAll();
+          expect(rows).to.be.an('array');
+          expect(rows.length).to.equal(1);
+          const row = rows[0] as Record<string, unknown>;
+          expect(row).to.have.property('x');
+          // SEA-side converter promotes a literal int to a number
+          // primitive; Thrift on the same query produces the same
+          // shape. We don't pin the exact JS type beyond "not null/
+          // undefined" to keep the test forward-compatible with
+          // converter changes — the load-bearing assertion is the
+          // single-row inline-batch drain.
+          expect(row.x).to.not.equal(null);
+          expect(row.x).to.not.equal(undefined);
+        } finally {
+          await operation.close();
+        }
+      } finally {
+        await session.close();
+      }
+    } finally {
+      await client.close();
+    }
+  });
 });