Merge pull request #419 from nitincchauhan/dev

Mediator: simplified check of validation modes

src/main/java/com/zaxxer/hikari/pool/HikariPool.java

@@ -59,7 +59,6 @@
 import com.zaxxer.hikari.util.ConcurrentBag;
 import com.zaxxer.hikari.util.ConcurrentBag.IBagStateListener;
 import com.zaxxer.hikari.util.DefaultThreadFactory;
-import com.zaxxer.hikari.util.PropertyElf;
 
 /**
  * This is the primary connection pool class that provides the basic
@@ -86,8 +85,9 @@ public class HikariPool implements HikariPoolMXBean, IBagStateListener
 
    private final JdbcMediator jdbcMediator;
    private final PoolMediator poolMediator;
-   private final AtomicInteger totalConnections;
    private final PoolEntryMediator entryMediator;
+
+   private final AtomicInteger totalConnections;
    private final ThreadPoolExecutor addConnectionExecutor;
    private final ThreadPoolExecutor closeConnectionExecutor;
 

src/main/java/com/zaxxer/hikari/pool/Mediator.java

@@ -56,9 +56,7 @@ public final class Mediator implements Mediators, JdbcMediator, PoolMediator, Po
    private final boolean isIsolateInternalQueries;
    private final AtomicReference<Throwable> lastConnectionFailure;
 
-   private volatile boolean isValidationQueryValid;
    private volatile boolean isValidChecked; 
-   private volatile boolean isValidSupported;
 
    public Mediator(final HikariPool pool)
    {
@@ -71,7 +69,6 @@ public Mediator(final HikariPool pool)
       this.isAutoCommit = config.isAutoCommit();
       this.transactionIsolation = getTransactionIsolation(config.getTransactionIsolation());
 
-      this.isValidSupported = true;
       this.isQueryTimeoutSupported = UNINITIALIZED;
       this.isNetworkTimeoutSupported = UNINITIALIZED;
       this.isUseJdbc4Validation = config.getConnectionTestQuery() == null;
@@ -116,11 +113,11 @@ public boolean isConnectionAlive(final Connection connection)
    {
       try {
          final long validationTimeout = config.getValidationTimeout();
-   
+
          if (isUseJdbc4Validation) {
             return connection.isValid((int) TimeUnit.MILLISECONDS.toSeconds(validationTimeout));
          }
-   
+
          final int originalTimeout = getAndSetNetworkTimeout(connection, validationTimeout);
 
          try (Statement statement = connection.createStatement()) {
@@ -134,9 +131,9 @@ public boolean isConnectionAlive(final Connection connection)
          if (isIsolateInternalQueries && !isAutoCommit) {
             connection.rollback();
          }
-   
+
          setNetworkTimeout(connection, originalTimeout);
-   
+
          return true;
       }
       catch (SQLException e) {
@@ -403,12 +400,10 @@ private Connection newConnection() throws Exception
     */
    private void setupConnection(final Connection connection, final long connectionTimeout) throws SQLException
    {
-      if (isUseJdbc4Validation && !isJdbc4ValidationSupported(connection)) {
-         throw new SQLException("Connection.isValid() is not supported, configure connection test query.");
-      }
-
       networkTimeout = getAndSetNetworkTimeout(connection, connectionTimeout);
 
+      checkValidationMode(connection);
+
       connection.setAutoCommit(isAutoCommit);
       connection.setReadOnly(isReadOnly);
 
@@ -424,39 +419,39 @@ private void setupConnection(final Connection connection, final long connectionT
          connection.setCatalog(catalog);
       }
 
-      executeSql(connection, config.getConnectionInitSql(), isAutoCommit);
-
-      if (!isUseJdbc4Validation && !isValidationQueryValid) {
-         executeSql(connection, config.getConnectionTestQuery(), isAutoCommit);
-         isValidationQueryValid = true;
-      }
+      executeSql(connection, config.getConnectionInitSql(), !isAutoCommit, false);
 
       setNetworkTimeout(connection, networkTimeout);
    }
 
    /**
-    * Return true if the driver appears to be JDBC 4.0 compliant.
+    * Execute isValid() or connection test query.
     *
     * @param connection a Connection to check
-    * @return true if JDBC 4.1 compliance, false otherwise
     */
-   private boolean isJdbc4ValidationSupported(final Connection connection)
+   private void checkValidationMode(final Connection connection) throws SQLException
    {
       if (!isValidChecked) {
-         try {
-            // We don't care how long the wait actually is here, just whether it returns without exception. This
-            // call will throw various exceptions in the case of a non-JDBC 4.0 compliant driver
-            connection.isValid(1);
+         if (isUseJdbc4Validation) {
+            try {
+               connection.isValid(1);
+            }
+            catch (Throwable e) {
+               LOGGER.debug("{} - Connection.isValid() is not supported, configure connection test query. ({})", poolName, e.getMessage());
+               throw e;
+            }
          }
-         catch (Throwable e) {
-            isValidSupported = false;
-            LOGGER.debug("{} - Connection.isValid() is not supported ({})", poolName, e.getMessage());
+         else {
+            try {
+               executeSql(connection, config.getConnectionTestQuery(), false, isIsolateInternalQueries && !isAutoCommit);
+            }
+            catch (Throwable e) {
+               LOGGER.debug("{} - Exception during executing connection test query. ({})", poolName, e.getMessage());
+               throw e;
+            }
          }
-
          isValidChecked = true;
       }
-
-      return isValidSupported;
    }
 
    /**
@@ -532,15 +527,19 @@ private void setNetworkTimeout(final Connection connection, final long timeoutMs
     * @param isAutoCommit whether to commit the SQL after execution or not
     * @throws SQLException throws if the init SQL execution fails
     */
-   private void executeSql(final Connection connection, final String sql, final boolean isAutoCommit) throws SQLException
+   private void executeSql(final Connection connection, final String sql, final boolean isCommit, final boolean isRollback) throws SQLException
    {
       if (sql != null) {
          try (Statement statement = connection.createStatement()) {
+
             statement.execute(sql);
 
-            if (!isAutoCommit) {
+            if (isCommit) {
                connection.commit();
             }
+            else if (isRollback) {
+               connection.rollback();
+            }
          }
       }
    }

src/main/java/com/zaxxer/hikari/pool/PoolEntry.java

@@ -80,7 +80,7 @@ public final class PoolEntry implements IConcurrentBagEntry
     *
     * @param lastAccess last access time-stamp
     */
-   public void returnPoolEntry(final long lastAccess)
+   public void recycle(final long lastAccess)
    {
       this.lastAccess = lastAccess;
       hikariPool.releaseConnection(this);
@@ -98,9 +98,6 @@ Connection createProxyConnection(final LeakTask leakTask, final long now)
    {
       return ProxyFactory.getProxyConnection(this, connection, openStatements, leakTask, now);
    }
-   // ***********************************************************************
-   //                      ConnectionState methods
-   // ***********************************************************************
 
    public void resetConnectionState(final ConnectionState connectionState, final int dirtyBits) throws SQLException
    {

src/main/java/com/zaxxer/hikari/proxy/ConnectionProxy.java

@@ -56,11 +56,11 @@ public abstract class ConnectionProxy implements IHikariConnectionProxy, Connect
    private long lastAccess;
    private boolean isCommitStateDirty;
 
-   public boolean isAutoCommit;
-   public int networkTimeout;
-   public int transactionIsolation;
-   public String dbcatalog;
-   public boolean isReadOnly;
+   private boolean isAutoCommit;
+   private int networkTimeout;
+   private int transactionIsolation;
+   private String dbcatalog;
+   private boolean isReadOnly;
 
    // static initializer
    static {
@@ -94,6 +94,10 @@ public final String toString()
          .append(delegate).toString();
    }
 
+   // ***********************************************************************
+   //                      ConnectionState methods
+   // ***********************************************************************
+
    /** {@inheritDoc} */
    @Override
    public final boolean getAutoCommitState()
@@ -122,6 +126,13 @@ public final boolean getReadOnlyState()
       return isReadOnly;
    }
 
+   /** {@inheritDoc} */
+   @Override
+   public final int getNetworkTimeoutState()
+   {
+      return networkTimeout;
+   }
+
    // ***********************************************************************
    //                      IHikariConnectionProxy methods
    // ***********************************************************************
@@ -239,7 +250,7 @@ public final void close() throws SQLException
          }
          finally {
             delegate = ClosedConnection.CLOSED_CONNECTION;
-            poolEntry.returnPoolEntry(lastAccess);
+            poolEntry.recycle(lastAccess);
          }
       }
    }

src/main/java/com/zaxxer/hikari/proxy/ConnectionState.java

@@ -31,6 +31,4 @@ public interface ConnectionState
    boolean getAutoCommitState();
 
    boolean getReadOnlyState();
-
-   long getLastAccess();
 }