docs: private boolean handleOpenLogSQLException(SQLException sqlex) throws InterruptedException {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "handleOpenLogSQLException", new java.lang.Object[] { sqlex, this });
  
          boolean retryBatch = true;
          boolean failAndReport = false;
          int batchRetries = 0;
  
          // Set the exception that will be reported
          _nonTransientExceptionAtOpen = sqlex;
  
          Connection conn = null;
  
          while (retryBatch && !failAndReport && batchRetries < _transientRetryAttempts) {
              // Should we attempt to reconnect? This method works through the set of SQL exceptions and will
              // return TRUE if we determine that a transient DB error has occurred
              retryBatch = sqlTransientErrorHandlingEnabled && isSQLErrorTransient(sqlex);
              batchRetries++;
              if (retryBatch) {
                  if (tc.isDebugEnabled())
                      Tr.debug(tc, "Try to reexecute the SQL using connection from DS: " + _theDS + ", attempt number: " + batchRetries);
                  if (_theDS != null) {
                      // Re-execute the SQL
                      try {
                          // Get a connection to database via its datasource
                          conn = _theDS.getConnection();
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Acquired connection in Database retry scenario");
                          conn.setAutoCommit(false);
                          Statement lockingStmt = conn.createStatement();
  
                          // Use RDBMS SELECT FOR UPDATE to lock table for recovery
                          String queryString = "SELECT SERVER_NAME" +
                                               " FROM " + _recoveryTableName + _logIdentifierString + _recoveryTableNameSuffix +
                                               " WHERE RU_ID=" + "-1 FOR UPDATE";
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Attempt to select the HA LOCKING ROW for UPDATE - " + queryString);
                          ResultSet lockingRS = lockingStmt.executeQuery(queryString);
                          // Update the HA DB lock and then recover
                          updateHADBLock(conn, lockingStmt, lockingRS);
  
                          // Clear out recovery caches in case they were partially filled before the failure.
                          _recoverableUnits.clear();
                          _recUnitIdTable = new RecoverableUnitIdTable();
  
                          // Drive recover again
                          recover(conn);
  
                          conn.commit();
                          // The Batch has executed successfully and we can continue processing
                          retryBatch = false;
                      } catch (SQLException sqlex2) {
                          // We've caught another SQLException. Assume that we've retried the connection too soon.
                          // Make sure we inspect the latest exception
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "reset the sqlex to " + sqlex2);
                          sqlex = sqlex2;
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "sleeping for " + _transientRetrySleepTime + " millisecs");
                          Thread.sleep(_transientRetrySleepTime);
                      } catch (Throwable exc) {
                          // Not a SQLException, break out of the loop and report the exception
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Failed got exception: " + exc);
                          for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
                              if (tc.isDebugEnabled())
                                  Tr.debug(tc, " " + ste);
                          }
  
                          failAndReport = true;
                          _nonTransientExceptionAtOpen = exc;
                      } finally {
                          // Tidy up the connection and its artefacets, if we can but allow
                          // processing to continue on the pre-determined path if we cannot.
                          if (conn != null) {
                              if (retryBatch) {
                                  // Attempt a rollback. If it fails, trace the failure but allow processing to continue
                                  try {
                                      conn.rollback();
                                  } catch (Throwable exc) {
                                      // Trace the exception
                                      if (tc.isDebugEnabled())
                                          Tr.debug(tc, "Rollback Failed, when handling OpenLog SQLException, got exception: " + exc);
                                  }
                              }
                              // Attempt a close. If it fails, trace the failure but allow processing to continue
                              try {
                                  conn.close();
                              } catch (Throwable exc) {
                                  // Trace the exception
                                  if (tc.isDebugEnabled())
                                      Tr.debug(tc, "Close Failed, when handling OpenLog SQLException, got exception: " + exc);
                              }
                          }
                      }
                  } else {
                      // This is unexpected and catastrophic, the reference to the DataSource is null
                      if (tc.isDebugEnabled())
                          Tr.debug(tc, "NULL DataSource reference");
                      failAndReport = true;
                  }
              } else
                  failAndReport = true;
          }
  
          if (tc.isEntryEnabled())
              Tr.exit(tc, "handleOpenLogSQLException", failAndReport);
          return failAndReport;
      }