fix(sea): address #411 review — fail-loud duration unit, interval test gaps

Addresses the P2 review comment on #411 (the interval/duration layer) and
cascades the #410 fixes underneath (this branch was rebased onto the
updated #410 tip). Validated against a live warehouse (interval-duration
+ interval-edge e2e) and unit tests.

- ArrowResultConverter.toNanoseconds: throw on an unrecognized Arrow
  duration unit instead of silently defaulting to NANOSECOND. The four
  units are exactly what SeaArrowIpcDurationFix stamps, so an unknown unit
  means the two sides drifted — fail loud, matching formatArrowInterval.

- SeaIntervalParity tests: add DAY-TIME via Duration(MILLISECOND) and
  Duration(SECOND) (only MICROSECOND/NANOSECOND were exercised), and a
  test asserting the converter throws (HiveDriverError) on a native
  non-YEAR_MONTH Arrow Interval rather than misreading it.

- interval-duration-e2e: flip the stale "raw Int64 on this layer" assertion
  to expect the formatted thrift string "1 02:03:04.000000000". That test
  was written on #410 (pre-formatter) and explicitly noted "#411 flips this
  to the formatted string" — now that #411's formatter is wired, the value
  is the byte-identical thrift DAY-TIME string.

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

Author: msrathore-db

lib/result/ArrowResultConverter.ts

@@ -116,6 +116,14 @@ function formatDurationToIntervalDayTime(value: bigint | number, unit: string):
  *   MILLISECOND → ×    1_000_000
  *   MICROSECOND → ×        1_000
  *   NANOSECOND  → ×            1
+ *
+ * Throws on any other unit rather than silently treating it as
+ * NANOSECOND. The four units above are exactly what
+ * `SeaArrowIpcDurationFix` enumerates when it stamps the
+ * `databricks.arrow.duration_unit` metadata, so an unrecognized unit
+ * here means the two sides have drifted — fail loud (matching
+ * `formatArrowInterval`'s stance) instead of emitting a confidently
+ * wrong value.
  */
 function toNanoseconds(value: bigint, unit: string): bigint {
   switch (unit) {
@@ -126,8 +134,12 @@ function toNanoseconds(value: bigint, unit: string): bigint {
     case 'MICROSECOND':
       return value * NS_PER_MICRO;
     case 'NANOSECOND':
-    default:
       return value;
+    default:
+      throw new HiveDriverError(
+        `SEA INTERVAL DAY-TIME: unrecognized Arrow duration unit ${JSON.stringify(unit)}; ` +
+          `expected one of SECOND / MILLISECOND / MICROSECOND / NANOSECOND`,
+      );
   }
 }
 

tests/e2e/sea/interval-duration-e2e.test.ts

@@ -93,12 +93,13 @@ describe('SEA INTERVAL DAY-TIME (Arrow Duration rewriter) end-to-end', function
     expect(row.dt, 'INTERVAL DAY-TIME value should be present').to.not.equal(undefined);
   });
 
-  it('surfaces the value as a raw Int64 on this layer (formatter is PR 3/3)', async () => {
+  it('surfaces the value as the formatted thrift INTERVAL DAY-TIME string (#411 formatter wired)', async () => {
     const row = await fetchOneRow(true, secrets as PecoSecrets);
-    // Documents the M0/2-of-3 contract: the rewriter makes the column
-    // *decodable* but the duration_unit formatter is not wired here yet, so the
-    // value is the raw integer microsecond/nanosecond count, not the thrift
-    // "1 02:03:04.000000000" string. (#411 flips this to the formatted string.)
-    expect(['number', 'bigint']).to.include(typeof row.dt);
+    // #411 wires the duration_unit formatter, so the raw Int64 the rewriter
+    // produces is rendered as the thrift "D HH:mm:ss.fffffffff" string —
+    // byte-identical to the Thrift path. (On the #410 layer this surfaced as
+    // the raw integer count.)
+    expect(typeof row.dt).to.equal('string');
+    expect(row.dt).to.equal('1 02:03:04.000000000');
   });
 });

tests/unit/sea/SeaIntervalParity.test.ts

@@ -61,6 +61,7 @@ import { TimeUnit as FbTimeUnit } from 'apache-arrow/fb/time-unit';
 
 import SeaOperationBackend from '../../../lib/sea/SeaOperationBackend';
 import ClientContextStub from '../.stubs/ClientContextStub';
+import HiveDriverError from '../../../lib/errors/HiveDriverError';
 import { DURATION_UNIT_METADATA_KEY as CONVERTER_DURATION_KEY } from '../../../lib/result/ArrowResultConverter';
 import { DURATION_UNIT_METADATA_KEY as REWRITER_DURATION_KEY } from '../../../lib/sea/SeaArrowIpcDurationFix';
 
@@ -306,6 +307,55 @@ describe('SeaOperationBackend — INTERVAL parity with thrift', () => {
     expect((rows[0] as any).iv).to.equal('1 02:03:04.123456789');
   });
 
+  it('DAY-TIME via Arrow Duration(MILLISECOND) scales correctly', async () => {
+    // 1 day + 2h + 3min + 4s = 93784 s = 93_784_000 ms.
+    const millis = BigInt(93_784) * BigInt(1_000);
+    const ipc = buildDurationIpc('iv', FbTimeUnit.MILLISECOND, [millis], 'INTERVAL');
+    const schemaIpc = ipcWithDurationSchema('iv', FbTimeUnit.MILLISECOND, 'INTERVAL');
+
+    const stub = new StatementStub(schemaIpc, [ipc]);
+    const backend = new SeaOperationBackend({ statement: stub, context: new ClientContextStub() });
+    const rows = await backend.fetchChunk({ limit: 100 });
+    expect(rows).to.have.length(1);
+    expect((rows[0] as any).iv).to.equal('1 02:03:04.000000000');
+  });
+
+  it('DAY-TIME via Arrow Duration(SECOND) scales correctly', async () => {
+    // 1 day + 2h + 3min + 4s = 93784 s.
+    const seconds = BigInt(93_784);
+    const ipc = buildDurationIpc('iv', FbTimeUnit.SECOND, [seconds], 'INTERVAL');
+    const schemaIpc = ipcWithDurationSchema('iv', FbTimeUnit.SECOND, 'INTERVAL');
+
+    const stub = new StatementStub(schemaIpc, [ipc]);
+    const backend = new SeaOperationBackend({ statement: stub, context: new ClientContextStub() });
+    const rows = await backend.fetchChunk({ limit: 100 });
+    expect(rows).to.have.length(1);
+    expect((rows[0] as any).iv).to.equal('1 02:03:04.000000000');
+  });
+
+  it('native non-YEAR_MONTH Arrow Interval is rejected (fail-loud, not misread as [days, ms])', async () => {
+    // The kernel only emits YEAR_MONTH as a native Arrow Interval; DAY-TIME
+    // arrives as Duration. A native DAY_TIME Interval reaching the converter
+    // means the kernel contract drifted — formatArrowInterval must throw
+    // rather than silently misread the value.
+    const fields = [withTypeName(new Field('iv', new Interval(IntervalUnit.DAY_TIME), true), 'INTERVAL')];
+    const schema = new Schema(fields);
+    const schemaIpc = ipcSchemaOnly(schema);
+    // One DAY_TIME value: [days=1, milliseconds=1000] packed as Int32Array(2).
+    const dataIpc = ipcFromColumns(schema, { iv: [Int32Array.from([1, 1000])] });
+
+    const stub = new StatementStub(schemaIpc, [dataIpc]);
+    const backend = new SeaOperationBackend({ statement: stub, context: new ClientContextStub() });
+    let thrown: unknown;
+    try {
+      await backend.fetchChunk({ limit: 100 });
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).to.be.instanceOf(HiveDriverError);
+    expect((thrown as Error).message).to.match(/YEAR_MONTH/);
+  });
+
   it('DAY-TIME zero → "0 00:00:00.000000000"', async () => {
     const ipc = buildDurationIpc('iv', FbTimeUnit.MICROSECOND, [BigInt(0)], 'INTERVAL');
     const schemaIpc = ipcWithDurationSchema('iv', FbTimeUnit.MICROSECOND, 'INTERVAL');