fix(bigquery-jdbc): fix Exception handling (#14566)

- Restore the thread's interrupt flag
(`Thread.currentThread().interrupt()`) on every
`InterruptedException` catch in Connection, Statement,
PreparedStatement, ResultSet,
  DatabaseMetaData and OpenTelemetry tracing.
- Throw checked `BigQueryJdbcException` instead of unchecked
`BigQueryJdbcRuntimeException`
from public JDBC methods (`execute*`, `executeBatch`, `getMoreResults`,
`next`,
`commit`, `rollback`, `close`, Write API batch), as JDBC requires
`SQLException`.
- Replace `IllegalStateException` with `BigQueryJdbcException` in
`checkClosed()`,
`checkIfEnabledSession()`, and `commit()`/`rollback()` when no
transaction is active.
  Methods that call these checks (`getDefaultDataset`, `getLocation`,
`getAuthProperties`, `getAutoCommit`, Statement constructors) now
declare
  `throws SQLException`.
- Wrap background fetch errors once: worker threads put the raw cause in
the buffer,
and `ResultSet.next()` wraps it a single time via
`backgroundFetchError()`, keeping
  the `BigQueryException` cause so its error details stay available.
- Harden `Connection.close()`: errors from `abortSession()` and
interrupts while waiting
for executors to shut down are collected as suppressed exceptions and
rethrown as
  `BigQueryJdbcException`. `isClosed` is now set even when close throws.
- Remove `throws InterruptedException` from `runQuery()`, which also
removes the
  duplicate catch blocks in its callers.
- Stop the GC daemon polling thread from crashing on interrupt; it now
logs the
  exception with its stack trace and restores the interrupt flag.
- `withTracing` no longer turns checked exceptions into unchecked ones.
- Remove the `BigQueryJdbcRuntimeException(String,
InterruptedException)` constructor.
- Update unit and integration tests to expect `SQLException` /
`BigQueryJdbcException`.

Author: Neenu1995

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/exception/BigQueryJdbcException.java

@@ -62,13 +62,22 @@ public BigQueryJdbcException(String message, Throwable cause) {
   }
 
   /**
-   * Constructs a new BigQueryJdbcException with the specified cause and a detail message of
-   * (cause==null ? null : cause.toString())
+   * Constructs a new BigQueryJdbcException with the specified cause and a detail message of {@code
+   * cause.toString()}. If {@code cause} is already a BigQueryJdbcException it is copied rather than
+   * wrapped, so re-throwing through this constructor does not nest the exception a second time.
    *
    * @param cause Throwable that is being converted.
    */
   public BigQueryJdbcException(Throwable cause) {
-    super(cause);
+    super(
+        cause instanceof BigQueryJdbcException ? cause.getMessage() : String.valueOf(cause),
+        cause instanceof SQLException ? ((SQLException) cause).getSQLState() : null,
+        cause instanceof SQLException ? ((SQLException) cause).getErrorCode() : 0,
+        cause instanceof BigQueryJdbcException ? cause.getCause() : cause);
+    if (cause instanceof BigQueryJdbcException) {
+      bigQueryException = ((BigQueryJdbcException) cause).bigQueryException;
+      setStackTrace(cause.getStackTrace());
+    }
   }
 
   public BigQueryException getBigQueryException() {

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/exception/BigQueryJdbcRuntimeException.java

@@ -36,16 +36,6 @@ public BigQueryJdbcRuntimeException(Throwable ex) {
     super(ex);
   }
 
-  /**
-   * Constructs a new BigQueryJdbcRuntimeException from a Throwable exception and a message.
-   *
-   * @param message The detail message.
-   * @param ex Throwable to be thrown.
-   */
-  public BigQueryJdbcRuntimeException(String message, InterruptedException ex) {
-    super(message, ex);
-  }
-
   public BigQueryJdbcRuntimeException(String message, Throwable ex) {
     super(BigQueryJdbcExceptionUtils.formatMessage(message, ex), ex);
   }

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryArrowResultSet.java

@@ -25,7 +25,6 @@
 import com.google.cloud.bigquery.Schema;
 import com.google.cloud.bigquery.StandardSQLTypeName;
 import com.google.cloud.bigquery.exception.BigQueryJdbcException;
-import com.google.cloud.bigquery.exception.BigQueryJdbcRuntimeException;
 import com.google.cloud.bigquery.storage.v1.ArrowRecordBatch;
 import com.google.cloud.bigquery.storage.v1.ArrowSchema;
 import io.opentelemetry.context.Scope;
@@ -280,7 +279,7 @@ public boolean next() throws SQLException {
           try (Scope scope = makeOriginalContextCurrent()) {
             BigQueryArrowBatchWrapper batchWrapper = this.buffer.take();
             if (batchWrapper.getException() != null) {
-              throw new BigQueryJdbcRuntimeException(batchWrapper.getException());
+              throw backgroundFetchError(batchWrapper.getException());
             }
             if (batchWrapper.isLast()) {
               /* Marks the end of the records */
@@ -309,10 +308,15 @@ else if (this.currentBatchRowIndex < this.vectorSchemaRoot.getRowCount()) {
           this.rowCount++;
           return true;
         }
-      } catch (InterruptedException | SQLException ex) {
+      } catch (SQLException ex) {
         throw new BigQueryJdbcException(
             "Error occurred while advancing the cursor. This could happen when connection is closed while the next method is being called.",
             ex);
+      } catch (InterruptedException ex) {
+        Thread.currentThread().interrupt();
+        throw new BigQueryJdbcException(
+            "Interrupted while advancing the cursor. This could happen when connection is closed while the next method is being called.",
+            ex);
       }
     }
     return false;

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryBaseResultSet.java

@@ -843,4 +843,11 @@ public void clearWarnings() throws SQLException {
     this.warnings = null;
     this.warningsLoaded = true;
   }
+
+  static BigQueryJdbcException backgroundFetchError(Exception cause) {
+    String msg = "Error occurred while fetching query results";
+    return cause instanceof BigQueryException
+        ? new BigQueryJdbcException(msg, (BigQueryException) cause)
+        : new BigQueryJdbcException(msg, cause);
+  }
 }

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryConnection.java

@@ -592,7 +592,7 @@ public PreparedStatement prepareStatement(String sql, int resultSetType, int res
     return prepareStatement(sql);
   }
 
-  public DatasetId getDefaultDataset() {
+  public DatasetId getDefaultDataset() throws BigQueryJdbcException {
     checkClosed();
     return this.defaultDataset;
   }
@@ -613,12 +613,12 @@ String getKmsKeyName() {
     return this.kmsKeyName;
   }
 
-  public String getLocation() {
+  public String getLocation() throws BigQueryJdbcException {
     checkClosed();
     return this.location;
   }
 
-  public Map<String, String> getAuthProperties() {
+  public Map<String, String> getAuthProperties() throws BigQueryJdbcException {
     checkClosed();
     return this.authProperties;
   }
@@ -678,7 +678,7 @@ SessionState getSessionStateSnapshot() {
    * For more information about transactions in BigQuery, see <a
    * href="https://cloud.google.com/bigquery/docs/transactions">Multi-statement transactions</a>.
    */
-  private void beginTransaction() {
+  private void beginTransaction() throws BigQueryJdbcException {
     LOG.finer("++enter++");
     SessionState snapshot = this.sessionState.get();
     QueryJobConfiguration.Builder transactionBeginJobConfig =
@@ -696,7 +696,8 @@ private void beginTransaction() {
       initSessionInfo(transactionResult.getSessionInfo().getSessionId());
       this.transactionStarted = true;
     } catch (InterruptedException ex) {
-      throw new BigQueryJdbcRuntimeException("Failed to begin transaction", ex);
+      Thread.currentThread().interrupt();
+      throw new BigQueryJdbcException("Failed to begin transaction", ex);
     }
   }
 
@@ -930,7 +931,7 @@ public void clearWarnings() {
   }
 
   @Override
-  public boolean getAutoCommit() {
+  public boolean getAutoCommit() throws SQLException {
     checkClosed();
     return this.autoCommit;
   }
@@ -954,16 +955,13 @@ public void setAutoCommit(boolean autoCommit) throws SQLException {
   }
 
   @Override
-  public void commit() {
+  public void commit() throws SQLException {
     checkClosed();
     checkIfEnabledSession("commit");
     if (!isTransactionStarted()) {
-      IllegalStateException ex =
-          new IllegalStateException(
-              "Cannot commit without an active transaction. Please set setAutoCommit to false to start"
-                  + " a transaction.");
-      LOG.severe(ex.getMessage(), ex);
-      throw ex;
+      throw new BigQueryJdbcException(
+          "Cannot commit without an active transaction. Please set setAutoCommit to false to start"
+              + " a transaction.");
     }
     commitTransaction();
     if (!getAutoCommit()) {
@@ -976,12 +974,9 @@ public void rollback() throws SQLException {
     checkClosed();
     checkIfEnabledSession("rollback");
     if (!isTransactionStarted()) {
-      IllegalStateException ex =
-          new IllegalStateException(
-              "Cannot rollback without an active transaction. Please set setAutoCommit to false to"
-                  + " start a transaction.");
-      LOG.severe(ex.getMessage(), ex);
-      throw ex;
+      throw new BigQueryJdbcException(
+          "Cannot rollback without an active transaction. Please set setAutoCommit to false to"
+              + " start a transaction.");
     }
     rollbackImpl();
   }
@@ -999,8 +994,11 @@ private void rollbackImpl() throws SQLException {
       if (!getAutoCommit()) {
         beginTransaction();
       }
-    } catch (InterruptedException | BigQueryException ex) {
+    } catch (BigQueryException ex) {
       throw new BigQueryJdbcException("Failed to rollback transaction", ex);
+    } catch (InterruptedException ex) {
+      Thread.currentThread().interrupt();
+      throw new BigQueryJdbcException("Interrupted during rollback transaction", ex);
     }
   }
 
@@ -1103,10 +1101,19 @@ private void closeImpl() throws SQLException {
 
       SessionState snapshot = this.sessionState.get();
       if (snapshot.sessionInfo != null && snapshot.createdByDriver) {
-        abortSession(snapshot);
+        try {
+          abortSession(snapshot);
+        } catch (SQLException e) {
+          if (exceptionToThrow == null) {
+            exceptionToThrow = e;
+          } else {
+            exceptionToThrow.addSuppressed(e);
+          }
+        }
       }
 
       boolean interrupted = Thread.currentThread().isInterrupted();
+      InterruptedException terminationInterruptedException = null;
 
       try {
         if (this.bigQueryReadClient != null) {
@@ -1135,6 +1142,7 @@ private void closeImpl() throws SQLException {
         }
       } catch (InterruptedException e) {
         interrupted = true;
+        terminationInterruptedException = e;
         if (this.bigQueryReadClient != null) {
           this.bigQueryReadClient.shutdownNow();
         }
@@ -1161,23 +1169,31 @@ private void closeImpl() throws SQLException {
 
       if (interrupted) {
         Thread.currentThread().interrupt();
-        throw new InterruptedException("Interrupted awaiting executor termination");
+      }
+      if (terminationInterruptedException != null) {
+        BigQueryJdbcException interruptedException =
+            new BigQueryJdbcException("Interrupted during close", terminationInterruptedException);
+        if (exceptionToThrow == null) {
+          exceptionToThrow = interruptedException;
+        } else {
+          exceptionToThrow.addSuppressed(interruptedException);
+        }
       }
     } catch (ConcurrentModificationException ex) {
       throw new BigQueryJdbcException("Concurrent modification during close", ex);
-    } catch (InterruptedException e) {
-      throw new BigQueryJdbcRuntimeException("Interrupted during close", e);
     } finally {
       BigQueryJdbcMdc.clear();
       BigQueryJdbcRootLogger.closeConnectionHandler(this.connectionId);
       BigQueryJdbcOpenTelemetry.unregisterConnection(this.connectionId);
       BigQueryJdbcOpenTelemetry.releaseSdk(this.openTelemetry);
       this.openTelemetry = null;
     }
+
+    this.isClosed = true;
+
     if (exceptionToThrow != null) {
       throw exceptionToThrow;
     }
-    this.isClosed = true;
   }
 
   ExecutorService getExecutorService() {
@@ -1193,22 +1209,16 @@ public boolean isClosed() {
     return this.isClosed;
   }
 
-  private void checkClosed() {
+  private void checkClosed() throws BigQueryJdbcException {
     if (isClosed()) {
-      IllegalStateException ex =
-          new IllegalStateException("This " + getClass().getName() + " has been closed");
-      LOG.severe(ex.getMessage(), ex);
-      throw ex;
+      throw new BigQueryJdbcException("This " + getClass().getName() + " has been closed");
     }
   }
 
-  private void checkIfEnabledSession(String methodName) {
+  private void checkIfEnabledSession(String methodName) throws BigQueryJdbcException {
     if (!this.enableSession) {
-      IllegalStateException ex =
-          new IllegalStateException(
-              String.format("Session needs to be enabled to use %s method.", methodName));
-      LOG.severe(ex.getMessage(), ex);
-      throw ex;
+      throw new BigQueryJdbcException(
+          String.format("Session needs to be enabled to use %s method.", methodName));
     }
   }
 
@@ -1519,7 +1529,7 @@ RetrySettings getRetrySettings() {
     return retrySettingsBuilder == null ? null : retrySettingsBuilder.build();
   }
 
-  private void commitTransaction() {
+  private void commitTransaction() throws BigQueryJdbcException {
     try {
       QueryJobConfiguration transactionCommitJobConfig =
           QueryJobConfiguration.newBuilder("COMMIT TRANSACTION;")
@@ -1530,11 +1540,12 @@ private void commitTransaction() {
       commitJob.waitFor();
       this.transactionStarted = false;
     } catch (InterruptedException ex) {
-      throw new BigQueryJdbcRuntimeException("Interrupted during commitTransaction", ex);
+      Thread.currentThread().interrupt();
+      throw new BigQueryJdbcException("Interrupted during commitTransaction", ex);
     }
   }
 
-  private void abortSession(SessionState snapshot) {
+  private void abortSession(SessionState snapshot) throws BigQueryJdbcException {
     try {
       LOG.fine("Aborting session on connection close: %s", snapshot.sessionInfo.getValue());
       QueryJobConfiguration abortSessionJobConfig =
@@ -1544,7 +1555,7 @@ private void abortSession(SessionState snapshot) {
       this.bigQuery.query(abortSessionJobConfig);
     } catch (InterruptedException ex) {
       Thread.currentThread().interrupt();
-      throw new BigQueryJdbcRuntimeException("Interrupted during session abort", ex);
+      throw new BigQueryJdbcException("Interrupted during session abort", ex);
     } catch (BigQueryException ex) {
       LOG.warning(
           "Failed to abort session during session abort (session may have already ended): "

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryDaemonPollingTask.java

@@ -118,7 +118,7 @@ else if (referenceQueueJsonRs != null) {
         throw new BigQueryJdbcRuntimeException("Null Reference Queue");
       }
     } catch (InterruptedException ex) {
-      throw new BigQueryJdbcRuntimeException("Interrupted in GC daemon task", ex);
+      LOG.warning(ex, "Interrupted in GC daemon task");
     }
   }
 }

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryDatabaseMetaData.java

@@ -3929,7 +3929,8 @@ public boolean isWrapperFor(Class<?> iface) throws SQLException {
    *     for querying BigQuery's metadata.
    * @see BigQueryConnection#isFilterTablesOnDefaultDataset()
    */
-  Tuple<String, String> determineEffectiveCatalogAndSchema(String catalog, String schemaPattern) {
+  Tuple<String, String> determineEffectiveCatalogAndSchema(String catalog, String schemaPattern)
+      throws BigQueryJdbcException {
     String effectiveCatalog = catalog;
     String effectiveSchemaPattern = schemaPattern;
 
@@ -4279,7 +4280,7 @@ private void waitForTasksCompletion(List<Future<?>> taskFutures)
       Thread.currentThread().interrupt();
       LOG.warning(
           "Fetcher thread interrupted while waiting for tasks. Attempting to cancel remaining tasks.");
-      throw new SQLException("Metadata fetch interrupted.", e);
+      throw new BigQueryJdbcException("Metadata fetch interrupted.", e);
     } finally {
       for (Future<?> future : taskFutures) {
         if (!future.isDone()) {
@@ -4298,6 +4299,9 @@ private BlockingQueue<BigQueryFieldValueListWrapper> fetchAndPopulateQueue(
       populateQueue(collectedResults, queue, resultSchemaFields);
       signalEndOfData(queue, resultSchemaFields);
       return queue;
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      throw new BigQueryJdbcException("Error during metadata fetch", e);
     } catch (Exception e) {
       if (e instanceof SQLException) {
         throw (SQLException) e;
@@ -4358,7 +4362,7 @@ private List<Dataset> fetchDatasetsForProject(
       return datasets != null ? datasets : Collections.emptyList();
     } catch (InterruptedException e) {
       Thread.currentThread().interrupt();
-      throw new SQLException(
+      throw new BigQueryJdbcException(
           "Interrupted while fetching matching datasets for project " + project, e);
     } catch (Exception e) {
       throw new SQLException("Failed to fetch matching datasets for project " + project, e);
@@ -4667,7 +4671,7 @@ private void processTargetRoutinesConcurrently(
       throw new SQLException("Error while fetching metadata", e);
     } catch (InterruptedException e) {
       Thread.currentThread().interrupt();
-      throw new SQLException("Interrupted while processing routines.", e);
+      throw new BigQueryJdbcException("Interrupted while processing routines.", e);
     } finally {
       activeFutures.forEach(future -> future.cancel(true));
     }
@@ -4796,7 +4800,7 @@ private void processTargetTablesConcurrently(
       throw new SQLException("Error while fetching metadata", e);
     } catch (InterruptedException e) {
       Thread.currentThread().interrupt();
-      throw new SQLException("Interrupted while processing tables.", e);
+      throw new BigQueryJdbcException("Interrupted while processing tables.", e);
     } finally {
       activeFutures.forEach(future -> future.cancel(true));
     }