feat: add preserveBigNumericPrecision connection option (Thrift + SEA)

The result converter coerces DECIMAL to an IEEE-754 double and BIGINT to a JS
number, silently rounding high-precision decimals and integers beyond 2^53.
This affects BOTH backends (verified end-to-end on Thrift:
CAST('123456789012345.6789' AS DECIMAL(38,4)) -> 123456789012345.67;
CAST(9007199254740993 AS BIGINT) -> 9007199254740992).

Expose `preserveBigNumericPrecision` as a public ConnectionOption (default
false → existing representation preserved, non-breaking). When enabled, DECIMAL
is returned as an exact string and BIGINT as a JS `bigint`. Threaded through
ClientConfig to both the Thrift (ARROW_BASED / URL_BASED ArrowResultConverter)
and SEA operation backends. SeaOperationBackend now reads the option instead of
hardcoding it on.

Verified end-to-end on Thrift: OFF → 123456789012345.67 / 9007199254740992
(number); ON → "123456789012345.6789" (string) / 9007199254740993 (bigint).
Build (tsconfig.build.json) + unit tests + prettier + eslint pass.

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

Author: msrathore-db

lib/DBSQLClient.ts

@@ -152,6 +152,8 @@ export default class DBSQLClient extends EventEmitter implements IDBSQLClient, I
 
       useLZ4Compression: true,
 
+      preserveBigNumericPrecision: false,
+
       // Telemetry defaults are sourced from DEFAULT_TELEMETRY_CONFIG so
       // every component reads from the same single frozen const. Mapping the
       // unprefixed TelemetryConfiguration keys to the `telemetry`-prefixed
@@ -604,6 +606,11 @@ export default class DBSQLClient extends EventEmitter implements IDBSQLClient, I
       this.config.enableMetricViewMetadata = options.enableMetricViewMetadata;
     }
 
+    // Opt-in: preserve DECIMAL (string) / BIGINT (bigint) precision in results.
+    if (options.preserveBigNumericPrecision !== undefined) {
+      this.config.preserveBigNumericPrecision = options.preserveBigNumericPrecision;
+    }
+
     // Override telemetry config if provided in options. Per-key narrowed copy
     // preserves the structural type system: `ConnectionOptions` and
     // `ClientConfig` declare identical types for these knobs, so a user

lib/contracts/IClientContext.ts

@@ -26,6 +26,12 @@ export interface ClientConfig {
   useLZ4Compression: boolean;
   enableMetricViewMetadata?: boolean;
 
+  // When true, DECIMAL values are returned as exact strings and 64-bit
+  // integers as JS `bigint`, instead of being coerced to a lossy `number`.
+  // Off by default to preserve the long-standing representation on both the
+  // Thrift and SEA backends. See `ConnectionOptions.preserveBigNumericPrecision`.
+  preserveBigNumericPrecision?: boolean;
+
   // Telemetry configuration
   telemetryEnabled?: boolean;
   telemetryBatchSize?: number;

lib/contracts/IDBSQLClient.ts

@@ -55,6 +55,15 @@ export type ConnectionOptions = {
   proxy?: ProxyOptions;
   enableMetricViewMetadata?: boolean;
 
+  /**
+   * Preserve full numeric precision in results. When `true`, DECIMAL columns
+   * are returned as exact strings and 64-bit integers (BIGINT) as JS `bigint`,
+   * instead of the default lossy coercion to a JS `number` (which silently
+   * rounds DECIMALs and integers beyond 2^53). Applies to both the Thrift and
+   * SEA backends. Defaults to `false` to preserve the existing representation.
+   */
+  preserveBigNumericPrecision?: boolean;
+
   /**
    * Extra HTTP headers attached to driver-owned out-of-band requests
    * (telemetry POSTs and feature-flag GETs). Not applied to the primary

lib/sea/SeaOperationBackend.ts

@@ -767,13 +767,12 @@ export default class SeaOperationBackend implements IOperationBackend {
     // SeaResultsProvider consumes only `fetchNextBatch`; both the async result
     // handle and the blocking statement satisfy that surface.
     this.resultsProvider = new SeaResultsProvider(handle as unknown as SeaStatement);
-    // The kernel always delivers native Arrow Decimal128 / Int64 (there is no
-    // server-side "decimals as string" mode like Thrift's
-    // `useArrowNativeTypes=false`), so preserve their precision here — DECIMAL
-    // as an exact string, BIGINT as a `bigint` — matching the precise values
-    // the Thrift backend returns by default.
+    // DECIMAL/BIGINT precision preservation is opt-in via the
+    // `preserveBigNumericPrecision` connection option (default off). The kernel
+    // always delivers native Arrow Decimal128 / Int64, so when enabled the
+    // converter renders DECIMAL as an exact string and BIGINT as a `bigint`.
     const converter = new ArrowResultConverter(this.context, this.resultsProvider, metadata, {
-      preserveBigNumericPrecision: true,
+      preserveBigNumericPrecision: this.context.getConfig().preserveBigNumericPrecision ?? false,
     });
     this.resultSlicer = new ResultSlicer(this.context, converter);
     return this.resultSlicer;

lib/thrift-backend/ThriftOperationBackend.ts

@@ -334,13 +334,15 @@ export default class ThriftOperationBackend implements IOperationBackend {
             this.context,
             new ArrowResultHandler(this.context, this._data, metadata),
             metadata,
+            { preserveBigNumericPrecision: this.context.getConfig().preserveBigNumericPrecision ?? false },
           );
           break;
         case TSparkRowSetType.URL_BASED_SET:
           resultSource = new ArrowResultConverter(
             this.context,
             new CloudFetchResultHandler(this.context, this._data, metadata, this.id),
             metadata,
+            { preserveBigNumericPrecision: this.context.getConfig().preserveBigNumericPrecision ?? false },
           );
           break;
         // no default