Fix cancel error handling: vendor code, telemetry level, SEA async path (#1425)

## Summary
Follow-up to #1291 addressing review feedback:

- **F2**: `getErrorCode()` now returns
`DatabricksDriverErrorCode.EXECUTE_STATEMENT_CANCELLED.ordinal()`
instead of 0. The 3-arg `DatabricksSQLException` constructor was
silently discarding the error code.
- **F3**: Cancellation exceptions use `silentExceptions=true` so BI-tool
cancellations (Tableau, Looker) don't emit ERROR-level telemetry.
Cancellations are logged at TRACE level instead.
- **F4**: SEA `getStatementResult()` now detects CANCELED state and
throws `HY008` — previously the async cancel path returned a
`DatabricksResultSet` wrapping null result data.
- **F5**: Added polling-path test (RUNNING → CANCELED during
`pollTillOperationFinished`) for Thrift, which had zero coverage.

## Test plan
- [x]
`DatabricksSdkClientTest#testHandleFailedExecution_CancelledState_ThrowsWithHY008`
— asserts HY008, message, and error code
- [x]
`DatabricksSdkClientTest#testHandleFailedExecution_FailedState_ThrowsWithoutHY008`
— unchanged
- [x]
`DatabricksSdkClientTest#testGetStatementResult_CancelledState_ThrowsWithHY008`
— **new** (F4)
- [x]
`DatabricksThriftAccessorTest#testGetStatementResult_cancelled_throwsWithHY008`
— now asserts error code
- [x]
`DatabricksThriftAccessorTest#testPollingPath_cancelledDuringExecution_throwsWithHY008`
— **new** (F5)

NO_CHANGELOG=true

This pull request was AI-assisted by Isaac.

---------

Signed-off-by: Gopal Lal <gopal.lal@databricks.com>

Author: gopalldb

src/main/java/com/databricks/jdbc/dbclient/impl/sqlexec/DatabricksSdkClient.java

@@ -427,6 +427,19 @@ public DatabricksResultSet getStatementResult(
       LOGGER.error(errorMessage, e);
       throw new DatabricksSQLException(errorMessage, e, DatabricksDriverErrorCode.SDK_CLIENT_ERROR);
     }
+
+    // Detect cancellation before constructing ResultSet (result data is null when cancelled)
+    if (response.getStatus() != null
+        && response.getStatus().getState() == StatementState.CANCELED) {
+      String cancelMessage = String.format("Statement [%s] was cancelled", statementId);
+      LOGGER.info(cancelMessage);
+      throw new DatabricksSQLException(
+          cancelMessage,
+          OPERATION_CANCELLED_SQLSTATE,
+          DatabricksDriverErrorCode.EXECUTE_STATEMENT_CANCELLED,
+          true);
+    }
+
     return new DatabricksResultSet(
         response.getStatus(),
         typedStatementId,
@@ -726,14 +739,16 @@ void handleFailedExecution(
     StatementState statementState = response.getStatus().getState();
     ServiceError error = response.getStatus().getError();
 
-    // Distinguish cancellation from failure
+    // Distinguish cancellation from failure — silentExceptions=true so cancellations
+    // (common in BI tools like Tableau/Looker) don't emit ERROR-level telemetry
     if (statementState == StatementState.CANCELED) {
       String cancelMessage = String.format("Statement [%s] was cancelled", statementId);
       LOGGER.info(cancelMessage);
       throw new DatabricksSQLException(
           cancelMessage,
           OPERATION_CANCELLED_SQLSTATE,
-          DatabricksDriverErrorCode.EXECUTE_STATEMENT_CANCELLED);
+          DatabricksDriverErrorCode.EXECUTE_STATEMENT_CANCELLED,
+          true);
     }
 
     String errorMessage =

src/main/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftAccessor.java

@@ -934,8 +934,13 @@ private <T extends TBase<T, F>, F extends TFieldIdEnum> boolean hasResultDataInD
   private DatabricksSQLException cancelledStatementException(String statementId) {
     String msg = String.format("Statement [%s] was cancelled", statementId);
     LOGGER.info(msg);
+    // silentExceptions=true: cancellations are common in BI tools and should not
+    // emit ERROR-level telemetry
     return new DatabricksSQLException(
-        msg, OPERATION_CANCELLED_SQLSTATE, DatabricksDriverErrorCode.EXECUTE_STATEMENT_CANCELLED);
+        msg,
+        OPERATION_CANCELLED_SQLSTATE,
+        DatabricksDriverErrorCode.EXECUTE_STATEMENT_CANCELLED,
+        true);
   }
 
   private boolean isErrorStatusCode(TStatus status) {

src/main/java/com/databricks/jdbc/exception/DatabricksSQLException.java

@@ -51,8 +51,16 @@ public DatabricksSQLException(String reason, String sqlState, boolean silentExce
 
   public DatabricksSQLException(
       String reason, String sqlState, DatabricksDriverErrorCode internalError) {
-    super(reason, sqlState);
-    logTelemetryEvent(sqlState, reason, false);
+    this(reason, sqlState, internalError, false);
+  }
+
+  public DatabricksSQLException(
+      String reason,
+      String sqlState,
+      DatabricksDriverErrorCode internalError,
+      boolean silentExceptions) {
+    super(reason, sqlState, internalError.getCode());
+    logTelemetryEvent(sqlState, reason, silentExceptions);
   }
 
   public DatabricksSQLException(String reason, String sqlState, int vendorCode) {

src/main/java/com/databricks/jdbc/model/telemetry/enums/DatabricksDriverErrorCode.java

@@ -1,48 +1,58 @@
 package com.databricks.jdbc.model.telemetry.enums;
 
 public enum DatabricksDriverErrorCode {
-  CONNECTION_ERROR,
-  CHUNK_DOWNLOAD_ERROR,
-  EXECUTE_STATEMENT_FAILED,
-  EXECUTE_STATEMENT_CANCELLED,
-  RESULT_SET_ERROR,
-  UNSUPPORTED_OPERATION,
-  NOT_IMPLEMENTED_OPERATION,
-  STATEMENT_EXECUTION_TIMEOUT,
-  STATEMENT_CLOSED,
-  CONNECTION_CLOSED,
-  LOGGING_INITIALISATION_ERROR,
-  RESULT_SET_CLOSED,
-  VOLUME_OPERATION_PARSING_ERROR,
-  THREAD_INTERRUPTED_ERROR,
-  INPUT_VALIDATION_ERROR,
-  COMPLEX_DATA_TYPE_STRUCT_CONVERSION_ERROR,
-  COMPLEX_DATA_TYPE_ARRAY_CONVERSION_ERROR,
-  COMPLEX_DATA_TYPE_MAP_CONVERSION_ERROR,
-  INVALID_STATE,
-  INLINE_CHUNK_PARSING_ERROR,
-  DECOMPRESSION_ERROR,
-  VOLUME_OPERATION_URL_GENERATION_ERROR,
-  VOLUME_OPERATION_LOCAL_FILE_EXISTS_ERROR,
-  VOLUME_OPERATION_EXCEPTION,
-  VOLUME_OPERATION_PUT_OPERATION_EXCEPTION,
-  VOLUME_OPERATION_DELETE_OPERATION_EXCEPTION,
-  VOLUME_OPERATION_FILE_DOWNLOAD_ERROR,
-  VOLUME_OPERATION_INVALID_STATE,
-  SESSION_ID_PARSING_EXCEPTION,
-  BATCH_EXECUTE_EXCEPTION,
-  TEMPORARY_REDIRECT_EXCEPTION,
-  JSON_PARSING_ERROR,
-  CATALOG_OR_SCHEMA_FETCH_ERROR,
-  INTEGRATION_TEST_ERROR,
-  SDK_CLIENT_ERROR,
-  OPERATION_TIMEOUT_ERROR,
-  SSL_HANDSHAKE_ERROR,
-  AUTH_ERROR,
-  INVALID_CHUNK_STATE_TRANSITION,
-  CHUNK_READY_ERROR,
-  TRANSACTION_SET_AUTOCOMMIT_ERROR,
-  TRANSACTION_COMMIT_ERROR,
-  TRANSACTION_ROLLBACK_ERROR,
-  RATE_LIMIT_EXCEEDED
+  CONNECTION_ERROR(1001),
+  CHUNK_DOWNLOAD_ERROR(1002),
+  EXECUTE_STATEMENT_FAILED(1003),
+  EXECUTE_STATEMENT_CANCELLED(1008),
+  RESULT_SET_ERROR(1004),
+  UNSUPPORTED_OPERATION(1005),
+  NOT_IMPLEMENTED_OPERATION(1006),
+  STATEMENT_EXECUTION_TIMEOUT(1007),
+  STATEMENT_CLOSED(1009),
+  CONNECTION_CLOSED(1010),
+  LOGGING_INITIALISATION_ERROR(1011),
+  RESULT_SET_CLOSED(1012),
+  VOLUME_OPERATION_PARSING_ERROR(1013),
+  THREAD_INTERRUPTED_ERROR(1014),
+  INPUT_VALIDATION_ERROR(1015),
+  COMPLEX_DATA_TYPE_STRUCT_CONVERSION_ERROR(1016),
+  COMPLEX_DATA_TYPE_ARRAY_CONVERSION_ERROR(1017),
+  COMPLEX_DATA_TYPE_MAP_CONVERSION_ERROR(1018),
+  INVALID_STATE(1019),
+  INLINE_CHUNK_PARSING_ERROR(1020),
+  DECOMPRESSION_ERROR(1021),
+  VOLUME_OPERATION_URL_GENERATION_ERROR(1022),
+  VOLUME_OPERATION_LOCAL_FILE_EXISTS_ERROR(1023),
+  VOLUME_OPERATION_EXCEPTION(1024),
+  VOLUME_OPERATION_PUT_OPERATION_EXCEPTION(1025),
+  VOLUME_OPERATION_DELETE_OPERATION_EXCEPTION(1026),
+  VOLUME_OPERATION_FILE_DOWNLOAD_ERROR(1027),
+  VOLUME_OPERATION_INVALID_STATE(1028),
+  SESSION_ID_PARSING_EXCEPTION(1029),
+  BATCH_EXECUTE_EXCEPTION(1030),
+  TEMPORARY_REDIRECT_EXCEPTION(1031),
+  JSON_PARSING_ERROR(1032),
+  CATALOG_OR_SCHEMA_FETCH_ERROR(1033),
+  INTEGRATION_TEST_ERROR(1034),
+  SDK_CLIENT_ERROR(1035),
+  OPERATION_TIMEOUT_ERROR(1036),
+  SSL_HANDSHAKE_ERROR(1037),
+  AUTH_ERROR(1038),
+  INVALID_CHUNK_STATE_TRANSITION(1039),
+  CHUNK_READY_ERROR(1040),
+  TRANSACTION_SET_AUTOCOMMIT_ERROR(1041),
+  TRANSACTION_COMMIT_ERROR(1042),
+  TRANSACTION_ROLLBACK_ERROR(1043),
+  RATE_LIMIT_EXCEEDED(1044);
+
+  private final int code;
+
+  DatabricksDriverErrorCode(int code) {
+    this.code = code;
+  }
+
+  public int getCode() {
+    return code;
+  }
 }

src/test/java/com/databricks/jdbc/dbclient/impl/sqlexec/DatabricksSdkClientTest.java

@@ -312,6 +312,7 @@ public void testHandleFailedExecution_CancelledState_ThrowsWithHY008() throws Ex
 
     assertEquals("HY008", exception.getSQLState());
     assertTrue(exception.getMessage().contains("was cancelled"));
+    assertEquals(1008, exception.getErrorCode()); // EXECUTE_STATEMENT_CANCELLED stable code
   }
 
   @Test
@@ -338,6 +339,34 @@ public void testHandleFailedExecution_FailedState_ThrowsWithoutHY008() throws Ex
     assertTrue(exception.getMessage().contains("execution failed"));
   }
 
+  @Test
+  public void testGetStatementResult_CancelledState_ThrowsWithHY008() throws Exception {
+    IDatabricksConnectionContext connectionContext =
+        DatabricksConnectionContext.parse(JDBC_URL, new Properties());
+    DatabricksSdkClient databricksSdkClient =
+        new DatabricksSdkClient(connectionContext, statementExecutionService, apiClient);
+
+    // Server returns CANCELED with null result data
+    StatementStatus cancelledStatus = new StatementStatus().setState(StatementState.CANCELED);
+    GetStatementResponse cancelledResponse = new GetStatementResponse();
+    cancelledResponse.setStatus(cancelledStatus);
+    cancelledResponse.setStatementId(STATEMENT_ID.toSQLExecStatementId());
+
+    when(apiClient.execute(any(Request.class), eq(GetStatementResponse.class)))
+        .thenReturn(cancelledResponse);
+
+    DatabricksSQLException exception =
+        assertThrows(
+            DatabricksSQLException.class,
+            () ->
+                databricksSdkClient.getStatementResult(
+                    STATEMENT_ID, mock(DatabricksSession.class), null));
+
+    assertEquals("HY008", exception.getSQLState());
+    assertTrue(exception.getMessage().contains("was cancelled"));
+    assertEquals(1008, exception.getErrorCode()); // EXECUTE_STATEMENT_CANCELLED stable code
+  }
+
   @Test
   public void testDisposition_arrowAndCloudFetchEnabled_usesExternalLinks() throws Exception {
     setupClientMocks(true, false);

src/test/java/com/databricks/jdbc/dbclient/impl/thrift/DatabricksThriftAccessorTest.java

@@ -471,6 +471,44 @@ void testGetStatementResult_cancelled_throwsWithHY008() throws Exception {
 
     assertEquals("HY008", exception.getSQLState());
     assertTrue(exception.getMessage().contains("was cancelled"));
+    assertEquals(1008, exception.getErrorCode()); // EXECUTE_STATEMENT_CANCELLED stable code
+  }
+
+  @Test
+  void testPollingPath_cancelledDuringExecution_throwsWithHY008() throws Exception {
+    setup(false);
+    TExecuteStatementReq request = new TExecuteStatementReq();
+    TExecuteStatementResp executeResp =
+        new TExecuteStatementResp()
+            .setOperationHandle(tOperationHandle)
+            .setStatus(new TStatus().setStatusCode(TStatusCode.SUCCESS_STATUS));
+    when(thriftClient.ExecuteStatement(request)).thenReturn(executeResp);
+
+    // First poll returns RUNNING, second returns CANCELED (simulates cancel during execution)
+    TGetOperationStatusResp runningResp =
+        new TGetOperationStatusResp()
+            .setStatus(new TStatus().setStatusCode(TStatusCode.STILL_EXECUTING_STATUS))
+            .setOperationState(TOperationState.RUNNING_STATE);
+    TGetOperationStatusResp cancelledResp =
+        new TGetOperationStatusResp()
+            .setStatus(new TStatus().setStatusCode(TStatusCode.SUCCESS_STATUS))
+            .setOperationState(TOperationState.CANCELED_STATE);
+    when(thriftClient.GetOperationStatus(operationStatusReq))
+        .thenReturn(runningResp)
+        .thenReturn(cancelledResp);
+
+    Statement statement = mock(Statement.class);
+    when(parentStatement.getStatement()).thenReturn(statement);
+    when(statement.getQueryTimeout()).thenReturn(0);
+
+    DatabricksSQLException exception =
+        assertThrows(
+            DatabricksSQLException.class,
+            () -> accessor.execute(request, parentStatement, session, StatementType.SQL));
+
+    assertEquals("HY008", exception.getSQLState());
+    assertTrue(exception.getMessage().contains("was cancelled"));
+    assertEquals(1008, exception.getErrorCode()); // EXECUTE_STATEMENT_CANCELLED stable code
   }
 
   @Test