more improvements to JDBC-related logging

gavinking · gavinking · commit 83bc8a96c445 · 2025-07-26T12:02:35.000+08:00
diff --git a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/JdbcLogging.java b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/JdbcLogging.java
@@ -140,40 +140,48 @@ public interface JdbcLogging extends BasicLogger {
 			id = 100018)
 	void logDriverInfo(String name, String version, int major, int minor, int jdbcMajor, int jdbcMinor);
 
-	@LogMessage(level = TRACE)
-	@Message(value = "Unable to reset connection back to auto-commit", id = 100019)
-	void unableToResetAutoCommit(@Cause Exception ignored);
-
 	@LogMessage(level = INFO)
 	@Message(value = "Unable to release isolated connection", id = 100020)
 	void unableToReleaseIsolatedConnection(@Cause Exception ignored);
 
+	@LogMessage(level = DEBUG)
+	@Message(value = "Unable to release connection", id = 100021)
+	void unableToReleaseConnection(@Cause Exception ignored);
+
 	@LogMessage(level = INFO)
-	@Message(value = "Unable to roll back isolated connection on exception ", id = 100021)
+	@Message(value = "Unable to roll back isolated connection on exception ", id = 100022)
 	void unableToRollBackIsolatedConnection(@Cause Exception ignored);
 
+	@LogMessage(level = TRACE)
+	@Message(value = "Unable to reset connection back to auto-commit enabled", id = 100040)
+	void unableToResetAutoCommitEnabled(@Cause Exception ignored);
+
+	@LogMessage(level = TRACE)
+	@Message(value = "Unable to reset connection back to auto-commit disabled", id = 100041)
+	void unableToResetAutoCommitDisabled(@Cause Exception ignored);
+
 	@LogMessage(level = DEBUG)
-	@Message(value = "Using default JDBC fetch size: %s", id = 100022)
+	@Message(value = "Using default JDBC fetch size: %s", id = 100122)
 	void usingFetchSize(int fetchSize);
 
 	@LogMessage(level = WARN)
-	@Message(value = "Low default JDBC fetch size: %s (consider setting 'hibernate.jdbc.fetch_size')", id = 100023)
+	@Message(value = "Low default JDBC fetch size: %s (consider setting 'hibernate.jdbc.fetch_size')", id = 100123)
 	void warnLowFetchSize(int fetchSize);
 
 	@LogMessage(level = TRACE)
-	@Message(value = "JDBC fetch size: %s", id = 100024)
+	@Message(value = "JDBC fetch size: %s", id = 100124)
 	void fetchSize(int fetchSize);
 
 	@LogMessage(level = DEBUG)
-	@Message(value = "Low JDBC fetch size: %s (consider setting 'hibernate.jdbc.fetch_size')", id = 100025)
+	@Message(value = "Low JDBC fetch size: %s (consider setting 'hibernate.jdbc.fetch_size')", id = 100125)
 	void lowFetchSize(int fetchSize);
 
 	@LogMessage(level = TRACE)
-	@Message(value = "Setting JDBC fetch size: %s", id = 100026)
+	@Message(value = "Setting JDBC fetch size: %s", id = 100126)
 	void settingFetchSize(int fetchSize);
 
 	@LogMessage(level = TRACE)
-	@Message(value = "Setting JDBC query timeout: %s", id = 100027)
+	@Message(value = "Setting JDBC query timeout: %s", id = 100127)
 	void settingQueryTimeout(int timeout);
 
 	@LogMessage(level = WARN)
diff --git a/hibernate-core/src/main/java/org/hibernate/engine/jdbc/env/internal/ExtractedDatabaseMetaDataImpl.java b/hibernate-core/src/main/java/org/hibernate/engine/jdbc/env/internal/ExtractedDatabaseMetaDataImpl.java
@@ -9,9 +9,7 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
-import java.util.Collections;
 import java.util.List;
-import java.util.stream.Collectors;
 
 import org.hibernate.HibernateException;
 import org.hibernate.engine.jdbc.connections.spi.JdbcConnectionAccess;
@@ -22,7 +20,9 @@
 import org.hibernate.tool.schema.extract.spi.ExtractionContext;
 import org.hibernate.tool.schema.extract.spi.SequenceInformation;
 
+import static java.util.Collections.emptyList;
 import static java.util.stream.StreamSupport.stream;
+import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_MESSAGE_LOGGER;
 
 /**
  * Standard implementation of {@link ExtractedDatabaseMetaData}
@@ -189,7 +189,7 @@ public synchronized List<SequenceInformation> getSequenceInformationList() {
 			return sequenceInformationList;
 		}
 		else {
-			return Collections.emptyList();
+			return emptyList();
 		}
 	}
 
@@ -335,7 +335,7 @@ private List<SequenceInformation> sequenceInformationList() {
 		try {
 			connection = connectionAccess.obtainConnection();
 			return stream( sequenceInformation( connection, jdbcEnvironment ).spliterator(), false )
-					.collect( Collectors.toList() );
+					.toList();
 		}
 		catch (SQLException e) {
 			throw new HibernateException( "Could not fetch the SequenceInformation from the database", e );
@@ -346,7 +346,7 @@ private List<SequenceInformation> sequenceInformationList() {
 					connectionAccess.releaseConnection( connection );
 				}
 				catch (SQLException exception) {
-					//ignored
+					JDBC_MESSAGE_LOGGER.unableToReleaseConnection( exception );
 				}
 			}
 		}
diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/mutation/internal/temptable/GlobalTemporaryTableStrategy.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/mutation/internal/temptable/GlobalTemporaryTableStrategy.java
@@ -19,6 +19,8 @@
 import org.hibernate.query.sqm.mutation.spi.AfterUseAction;
 import org.jboss.logging.Logger;
 
+import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_MESSAGE_LOGGER;
+
 /**
  * Strategy based on ANSI SQL's definition of a "global temporary table".
  *
@@ -91,7 +93,8 @@ public void prepare(MappingModelCreationProcess mappingModelCreationProcess, Jdb
 				try {
 					connectionAccess.releaseConnection( connection );
 				}
-				catch (SQLException ignore) {
+				catch (SQLException exception) {
+					JDBC_MESSAGE_LOGGER.unableToReleaseConnection( exception );
 				}
 			}
 		}
@@ -132,7 +135,8 @@ public void release(SessionFactoryImplementor sessionFactory, JdbcConnectionAcce
 			try {
 				connectionAccess.releaseConnection( connection );
 			}
-			catch (SQLException ignore) {
+			catch (SQLException exception) {
+				JDBC_MESSAGE_LOGGER.unableToReleaseConnection( exception );
 			}
 		}
 	}
diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/mutation/internal/temptable/PersistentTableStrategy.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/mutation/internal/temptable/PersistentTableStrategy.java
@@ -19,6 +19,8 @@
 import org.hibernate.query.sqm.mutation.spi.AfterUseAction;
 import org.jboss.logging.Logger;
 
+import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_MESSAGE_LOGGER;
+
 /**
  * This is a strategy that mimics temporary tables for databases which do not support
  * temporary tables.  It follows a pattern similar to the ANSI SQL definition of global
@@ -116,7 +118,8 @@ public void prepare(
 			try {
 				connectionAccess.releaseConnection( connection );
 			}
-			catch (SQLException ignore) {
+			catch (SQLException exception) {
+				JDBC_MESSAGE_LOGGER.unableToReleaseConnection( exception );
 			}
 		}
 	}
@@ -156,7 +159,8 @@ public void release(
 			try {
 				connectionAccess.releaseConnection( connection );
 			}
-			catch (SQLException ignore) {
+			catch (SQLException exception) {
+				JDBC_MESSAGE_LOGGER.unableToReleaseConnection( exception );
 			}
 		}
 	}
diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcIsolationDelegate.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcIsolationDelegate.java
@@ -120,7 +120,7 @@ private static void resetAutoCommit(boolean transacted, boolean wasAutoCommit, C
 				connection.setAutoCommit( true );
 			}
 			catch ( Exception exception ) {
-				JDBC_MESSAGE_LOGGER.unableToResetAutoCommit( exception );
+				JDBC_MESSAGE_LOGGER.unableToResetAutoCommitEnabled( exception );
 			}
 		}
 	}
diff --git a/hibernate-core/src/main/java/org/hibernate/tool/schema/extract/internal/ExtractionContextImpl.java b/hibernate-core/src/main/java/org/hibernate/tool/schema/extract/internal/ExtractionContextImpl.java
@@ -15,6 +15,8 @@
 import org.hibernate.service.ServiceRegistry;
 import org.hibernate.tool.schema.extract.spi.ExtractionContext;
 
+import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_MESSAGE_LOGGER;
+
 /**
  * @author Steve Ebersole
  */
@@ -109,7 +111,8 @@ public void cleanup() {
 			try {
 				jdbcConnectionAccess.releaseConnection( jdbcConnection );
 			}
-			catch (SQLException ignore) {
+			catch (SQLException exception) {
+				JDBC_MESSAGE_LOGGER.unableToReleaseConnection( exception );
 			}
 		}
 	}
diff --git a/hibernate-core/src/main/java/org/hibernate/tool/schema/internal/DdlTransactionIsolatorProvidedConnectionImpl.java b/hibernate-core/src/main/java/org/hibernate/tool/schema/internal/DdlTransactionIsolatorProvidedConnectionImpl.java
@@ -68,8 +68,8 @@ public void release() {
 			// and we don't have access to it upon releasing via the DdlTransactionIsolatorProvidedConnectionImpl.
 			connectionAccess.releaseConnection( null );
 		}
-		catch (SQLException ignored) {
-			JDBC_MESSAGE_LOGGER.unableToReleaseIsolatedConnection( ignored );
+		catch (SQLException exception) {
+			JDBC_MESSAGE_LOGGER.unableToReleaseIsolatedConnection( exception );
 		}
 	}
 }
diff --git a/hibernate-core/src/main/java/org/hibernate/tool/schema/internal/exec/JdbcConnectionAccessConnectionProviderImpl.java b/hibernate-core/src/main/java/org/hibernate/tool/schema/internal/exec/JdbcConnectionAccessConnectionProviderImpl.java
@@ -13,6 +13,8 @@
 
 import org.jboss.logging.Logger;
 
+import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_MESSAGE_LOGGER;
+
 /**
  * Implementation of JdbcConnectionAccess for use in cases where we
  * leverage a ConnectionProvider for access to JDBC Connections.
@@ -43,14 +45,14 @@ public JdbcConnectionAccessConnectionProviderImpl(ConnectionProvider connectionP
 				try {
 					jdbcConnection.setAutoCommit( true );
 				}
-				catch (SQLException e) {
+				catch (SQLException exception) {
 					throw new PersistenceException(
 							String.format(
 									"Could not set provided connection [%s] to auto-commit mode" +
 											" (needed for schema generation)",
 									jdbcConnection
 							),
-							e
+							exception
 					);
 				}
 			}
@@ -88,8 +90,8 @@ public void releaseConnection(Connection connection) throws SQLException {
 					jdbcConnection.setAutoCommit( false );
 				}
 			}
-			catch (SQLException e) {
-				log.info( "Was unable to reset JDBC connection to no longer be in auto-commit mode" );
+			catch (SQLException exception) {
+				JDBC_MESSAGE_LOGGER.unableToResetAutoCommitDisabled( exception );
 			}
 		}
 
diff --git a/hibernate-core/src/main/java/org/hibernate/tool/schema/internal/exec/JdbcConnectionAccessProvidedConnectionImpl.java b/hibernate-core/src/main/java/org/hibernate/tool/schema/internal/exec/JdbcConnectionAccessProvidedConnectionImpl.java
@@ -12,6 +12,8 @@
 
 import org.jboss.logging.Logger;
 
+import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_MESSAGE_LOGGER;
+
 /**
  * Implementation of JdbcConnectionAccess for cases where we are provided
  * a JDBC Connection to use.
@@ -34,14 +36,14 @@ public JdbcConnectionAccessProvidedConnectionImpl(Connection jdbcConnection) {
 				try {
 					jdbcConnection.setAutoCommit( true );
 				}
-				catch (SQLException e) {
+				catch (SQLException exception) {
 					throw new PersistenceException(
 							String.format(
 									"Could not set provided connection [%s] to auto-commit mode" +
 											" (needed for schema generation)",
 									jdbcConnection
 							),
-							e
+							exception
 					);
 				}
 			}
@@ -61,16 +63,17 @@ public Connection obtainConnection() throws SQLException {
 
 	@Override
 	public void releaseConnection(Connection connection) throws SQLException {
-		// NOTE : reset auto-commit, but *do not* close the Connection.  The application handed us this connection
+		// NOTE: reset auto-commit, but *do not* close the Connection.
+		//       The application handed us this connection.
 
 		if ( !wasInitiallyAutoCommit ) {
 			try {
 				if ( jdbcConnection.getAutoCommit() ) {
 					jdbcConnection.setAutoCommit( false );
 				}
 			}
-			catch (SQLException e) {
-				log.info( "Was unable to reset JDBC connection to no longer be in auto-commit mode" );
+			catch (SQLException exception) {
+				JDBC_MESSAGE_LOGGER.unableToResetAutoCommitDisabled( exception );
 			}
 		}
 	}

Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,7 @@`
`9`	`9`	`import java.sql.ResultSet;`
`10`	`10`	`import java.sql.SQLException;`
`11`	`11`	`import java.sql.Statement;`
`12`		`-import java.util.Collections;`
`13`	`12`	`import java.util.List;`
`14`		`-import java.util.stream.Collectors;`
`15`	`13`
`16`	`14`	`import org.hibernate.HibernateException;`
`17`	`15`	`import org.hibernate.engine.jdbc.connections.spi.JdbcConnectionAccess;`
`@@ -22,7 +20,9 @@`
`22`	`20`	`import org.hibernate.tool.schema.extract.spi.ExtractionContext;`
`23`	`21`	`import org.hibernate.tool.schema.extract.spi.SequenceInformation;`
`24`	`22`
	`23`	`+import static java.util.Collections.emptyList;`
`25`	`24`	`import static java.util.stream.StreamSupport.stream;`
	`25`	`+import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_MESSAGE_LOGGER;`
`26`	`26`
`27`	`27`	`/**`
`28`	`28`	`* Standard implementation of {@link ExtractedDatabaseMetaData}`
`@@ -189,7 +189,7 @@ public synchronized List<SequenceInformation> getSequenceInformationList() {`
`189`	`189`	`return sequenceInformationList;`
`190`	`190`	`}`
`191`	`191`	`else {`
`192`		`- return Collections.emptyList();`
	`192`	`+ return emptyList();`
`193`	`193`	`}`
`194`	`194`	`}`
`195`	`195`
`@@ -335,7 +335,7 @@ private List<SequenceInformation> sequenceInformationList() {`
`335`	`335`	`try {`
`336`	`336`	`connection = connectionAccess.obtainConnection();`
`337`	`337`	`return stream( sequenceInformation( connection, jdbcEnvironment ).spliterator(), false )`
`338`		`- .collect( Collectors.toList() );`
	`338`	`+ .toList();`
`339`	`339`	`}`
`340`	`340`	`catch (SQLException e) {`
`341`	`341`	`throw new HibernateException( "Could not fetch the SequenceInformation from the database", e );`
`@@ -346,7 +346,7 @@ private List<SequenceInformation> sequenceInformationList() {`
`346`	`346`	`connectionAccess.releaseConnection( connection );`
`347`	`347`	`}`
`348`	`348`	`catch (SQLException exception) {`
`349`		`- //ignored`
	`349`	`+ JDBC_MESSAGE_LOGGER.unableToReleaseConnection( exception );`
`350`	`350`	`}`
`351`	`351`	`}`
`352`	`352`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,8 @@`
`19`	`19`	`import org.hibernate.query.sqm.mutation.spi.AfterUseAction;`
`20`	`20`	`import org.jboss.logging.Logger;`
`21`	`21`
	`22`	`+import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_MESSAGE_LOGGER;`
	`23`	`+`
`22`	`24`	`/**`
`23`	`25`	`* Strategy based on ANSI SQL's definition of a "global temporary table".`
`24`	`26`	`*`
`@@ -91,7 +93,8 @@ public void prepare(MappingModelCreationProcess mappingModelCreationProcess, Jdb`
`91`	`93`	`try {`
`92`	`94`	`connectionAccess.releaseConnection( connection );`
`93`	`95`	`}`
`94`		`- catch (SQLException ignore) {`
	`96`	`+ catch (SQLException exception) {`
	`97`	`+ JDBC_MESSAGE_LOGGER.unableToReleaseConnection( exception );`
`95`	`98`	`}`
`96`	`99`	`}`
`97`	`100`	`}`
`@@ -132,7 +135,8 @@ public void release(SessionFactoryImplementor sessionFactory, JdbcConnectionAcce`
`132`	`135`	`try {`
`133`	`136`	`connectionAccess.releaseConnection( connection );`
`134`	`137`	`}`
`135`		`- catch (SQLException ignore) {`
	`138`	`+ catch (SQLException exception) {`
	`139`	`+ JDBC_MESSAGE_LOGGER.unableToReleaseConnection( exception );`
`136`	`140`	`}`
`137`	`141`	`}`
`138`	`142`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ private static void resetAutoCommit(boolean transacted, boolean wasAutoCommit, C`
`120`	`120`	`connection.setAutoCommit( true );`
`121`	`121`	`}`
`122`	`122`	`catch ( Exception exception ) {`
`123`		`- JDBC_MESSAGE_LOGGER.unableToResetAutoCommit( exception );`
	`123`	`+ JDBC_MESSAGE_LOGGER.unableToResetAutoCommitEnabled( exception );`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,8 @@`
`15`	`15`	`import org.hibernate.service.ServiceRegistry;`
`16`	`16`	`import org.hibernate.tool.schema.extract.spi.ExtractionContext;`
`17`	`17`
	`18`	`+import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_MESSAGE_LOGGER;`
	`19`	`+`
`18`	`20`	`/**`
`19`	`21`	`* @author Steve Ebersole`
`20`	`22`	`*/`
`@@ -109,7 +111,8 @@ public void cleanup() {`
`109`	`111`	`try {`
`110`	`112`	`jdbcConnectionAccess.releaseConnection( jdbcConnection );`
`111`	`113`	`}`
`112`		`- catch (SQLException ignore) {`
	`114`	`+ catch (SQLException exception) {`
	`115`	`+ JDBC_MESSAGE_LOGGER.unableToReleaseConnection( exception );`
`113`	`116`	`}`
`114`	`117`	`}`
`115`	`118`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,8 +68,8 @@ public void release() {`
`68`	`68`	`// and we don't have access to it upon releasing via the DdlTransactionIsolatorProvidedConnectionImpl.`
`69`	`69`	`connectionAccess.releaseConnection( null );`
`70`	`70`	`}`
`71`		`- catch (SQLException ignored) {`
`72`		`- JDBC_MESSAGE_LOGGER.unableToReleaseIsolatedConnection( ignored );`
	`71`	`+ catch (SQLException exception) {`
	`72`	`+ JDBC_MESSAGE_LOGGER.unableToReleaseIsolatedConnection( exception );`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,8 @@`
`13`	`13`
`14`	`14`	`import org.jboss.logging.Logger;`
`15`	`15`
	`16`	`+import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_MESSAGE_LOGGER;`
	`17`	`+`
`16`	`18`	`/**`
`17`	`19`	`* Implementation of JdbcConnectionAccess for use in cases where we`
`18`	`20`	`* leverage a ConnectionProvider for access to JDBC Connections.`
`@@ -43,14 +45,14 @@ public JdbcConnectionAccessConnectionProviderImpl(ConnectionProvider connectionP`
`43`	`45`	`try {`
`44`	`46`	`jdbcConnection.setAutoCommit( true );`
`45`	`47`	`}`
`46`		`- catch (SQLException e) {`
	`48`	`+ catch (SQLException exception) {`
`47`	`49`	`throw new PersistenceException(`
`48`	`50`	`String.format(`
`49`	`51`	`"Could not set provided connection [%s] to auto-commit mode" +`
`50`	`52`	`" (needed for schema generation)",`
`51`	`53`	`jdbcConnection`
`52`	`54`	`),`
`53`		`- e`
	`55`	`+ exception`
`54`	`56`	`);`
`55`	`57`	`}`
`56`	`58`	`}`
`@@ -88,8 +90,8 @@ public void releaseConnection(Connection connection) throws SQLException {`
`88`	`90`	`jdbcConnection.setAutoCommit( false );`
`89`	`91`	`}`
`90`	`92`	`}`
`91`		`- catch (SQLException e) {`
`92`		`- log.info( "Was unable to reset JDBC connection to no longer be in auto-commit mode" );`
	`93`	`+ catch (SQLException exception) {`
	`94`	`+ JDBC_MESSAGE_LOGGER.unableToResetAutoCommitDisabled( exception );`
`93`	`95`	`}`
`94`	`96`	`}`
`95`	`97`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,8 @@`
`12`	`12`
`13`	`13`	`import org.jboss.logging.Logger;`
`14`	`14`
	`15`	`+import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_MESSAGE_LOGGER;`
	`16`	`+`
`15`	`17`	`/**`
`16`	`18`	`* Implementation of JdbcConnectionAccess for cases where we are provided`
`17`	`19`	`* a JDBC Connection to use.`
`@@ -34,14 +36,14 @@ public JdbcConnectionAccessProvidedConnectionImpl(Connection jdbcConnection) {`
`34`	`36`	`try {`
`35`	`37`	`jdbcConnection.setAutoCommit( true );`
`36`	`38`	`}`
`37`		`- catch (SQLException e) {`
	`39`	`+ catch (SQLException exception) {`
`38`	`40`	`throw new PersistenceException(`
`39`	`41`	`String.format(`
`40`	`42`	`"Could not set provided connection [%s] to auto-commit mode" +`
`41`	`43`	`" (needed for schema generation)",`
`42`	`44`	`jdbcConnection`
`43`	`45`	`),`
`44`		`- e`
	`46`	`+ exception`
`45`	`47`	`);`
`46`	`48`	`}`
`47`	`49`	`}`
`@@ -61,16 +63,17 @@ public Connection obtainConnection() throws SQLException {`
`61`	`63`
`62`	`64`	`@Override`
`63`	`65`	`public void releaseConnection(Connection connection) throws SQLException {`
`64`		`- // NOTE : reset auto-commit, but do not close the Connection. The application handed us this connection`
	`66`	`+ // NOTE: reset auto-commit, but do not close the Connection.`
	`67`	`+ // The application handed us this connection.`
`65`	`68`
`66`	`69`	`if ( !wasInitiallyAutoCommit ) {`
`67`	`70`	`try {`
`68`	`71`	`if ( jdbcConnection.getAutoCommit() ) {`
`69`	`72`	`jdbcConnection.setAutoCommit( false );`
`70`	`73`	`}`
`71`	`74`	`}`
`72`		`- catch (SQLException e) {`
`73`		`- log.info( "Was unable to reset JDBC connection to no longer be in auto-commit mode" );`
	`75`	`+ catch (SQLException exception) {`
	`76`	`+ JDBC_MESSAGE_LOGGER.unableToResetAutoCommitDisabled( exception );`
`74`	`77`	`}`
`75`	`78`	`}`
`76`	`79`	`}`