use JDBC_LOGGER for logging resource-local tx management

gavinking · gavinking · commit 4ddc36f68132 · 2025-07-14T15:30:26.000+02:00
just like we now use JTA_LOGGER for JTA tx management
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
@@ -138,4 +138,8 @@ public interface JdbcLogging extends BasicLogger {
 				JDBC version: %s.%s""",
 			id = 100018)
 	void logDriverInfo(String name, String version, int major, int minor, int jdbcMajor, int jdbcMinor);
+
+	@LogMessage(level = WARN)
+	@Message(value = "Called joinTransaction() on a non-JTA EntityManager (ignoring)", id = 100020)
+	void callingJoinTransactionOnNonJtaEntityManager();
 }
diff --git a/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java b/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java
@@ -71,10 +71,6 @@ public interface CoreMessageLogger extends BasicLogger {
 	@Message(value = "Second-level cache disabled", id = 26)
 	void noRegionFactory();
 
-	@LogMessage(level = WARN)
-	@Message(value = "Calling joinTransaction() on a non JTA EntityManager", id = 27)
-	void callingJoinTransactionOnNonJtaEntityManager();
-
 	@LogMessage(level = DEBUG)
 	@Message(value = "Instantiating factory [%s] with settings: %s", id = 30)
 	void instantiatingFactory(String uuid, Map<String, Object> settings);
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
@@ -23,7 +23,7 @@
  * @author Andrea Boriero
  */
 public class JdbcIsolationDelegate implements IsolationDelegate {
-	private static final CoreMessageLogger LOG = CoreLogging.messageLogger( JdbcIsolationDelegate.class );
+	private static final CoreMessageLogger log = CoreLogging.messageLogger( JdbcIsolationDelegate.class );
 
 	private final JdbcConnectionAccess connectionAccess;
 	private final SqlExceptionHelper sqlExceptionHelper;
@@ -33,10 +33,7 @@ public JdbcIsolationDelegate(TransactionCoordinatorOwner transactionCoordinatorO
 	}
 
 	public JdbcIsolationDelegate(JdbcSessionOwner jdbcSessionOwner) {
-		this(
-				jdbcSessionOwner.getJdbcConnectionAccess(),
-				jdbcSessionOwner.getSqlExceptionHelper()
-		);
+		this( jdbcSessionOwner.getJdbcConnectionAccess(), jdbcSessionOwner.getSqlExceptionHelper() );
 	}
 
 	public JdbcIsolationDelegate(JdbcConnectionAccess connectionAccess, SqlExceptionHelper sqlExceptionHelper) {
@@ -80,7 +77,7 @@ public <T> T delegateWork(WorkExecutorVisitable<T> work, boolean transacted) thr
 					}
 				}
 				catch ( Exception exception ) {
-					LOG.unableToRollbackConnection( exception );
+					log.unableToRollbackConnection( exception );
 				}
 
 				if ( e instanceof HibernateException ) {
@@ -99,14 +96,14 @@ else if ( e instanceof SQLException sqle ) {
 						connection.setAutoCommit( true );
 					}
 					catch ( Exception ignore ) {
-						LOG.trace( "was unable to reset connection back to auto-commit" );
+						log.trace( "Unable to reset connection back to auto-commit" );
 					}
 				}
 				try {
 					jdbcConnectionAccess().releaseConnection( connection );
 				}
 				catch ( Exception ignore ) {
-					LOG.unableToReleaseIsolatedConnection( ignore );
+					log.unableToReleaseIsolatedConnection( ignore );
 				}
 			}
 		}
diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcResourceLocalTransactionCoordinatorBuilderImpl.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcResourceLocalTransactionCoordinatorBuilderImpl.java
@@ -26,15 +26,15 @@ public class JdbcResourceLocalTransactionCoordinatorBuilderImpl implements Trans
 	/**
 	 * Singleton access
 	 */
-	public static final JdbcResourceLocalTransactionCoordinatorBuilderImpl INSTANCE = new JdbcResourceLocalTransactionCoordinatorBuilderImpl();
+	public static final TransactionCoordinatorBuilder INSTANCE = new JdbcResourceLocalTransactionCoordinatorBuilderImpl();
 
 	@Override
 	public TransactionCoordinator buildTransactionCoordinator(TransactionCoordinatorOwner owner, Options options) {
-		if ( owner instanceof JdbcResourceTransactionAccess ) {
+		if ( owner instanceof JdbcResourceTransactionAccess transactionAccess ) {
 			return new JdbcResourceLocalTransactionCoordinatorImpl(
 					this,
 					owner,
-					(JdbcResourceTransactionAccess) owner
+					transactionAccess
 			);
 		}
 
diff --git a/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcResourceLocalTransactionCoordinatorImpl.java b/hibernate-core/src/main/java/org/hibernate/resource/transaction/backend/jdbc/internal/JdbcResourceLocalTransactionCoordinatorImpl.java
@@ -12,7 +12,6 @@
 import jakarta.transaction.Status;
 
 import org.hibernate.resource.transaction.spi.IsolationDelegate;
-import org.hibernate.internal.CoreMessageLogger;
 import org.hibernate.jpa.spi.JpaCompliance;
 import org.hibernate.resource.transaction.backend.jdbc.spi.JdbcResourceTransaction;
 import org.hibernate.resource.transaction.backend.jdbc.spi.JdbcResourceTransactionAccess;
@@ -25,7 +24,8 @@
 import org.hibernate.resource.transaction.spi.TransactionStatus;
 
 import static java.util.Collections.emptyList;
-import static org.hibernate.internal.CoreLogging.messageLogger;
+import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_LOGGER;
+import static org.hibernate.engine.jdbc.JdbcLogging.JDBC_MESSAGE_LOGGER;
 
 /**
  * An implementation of {@link TransactionCoordinator} based on managing a
@@ -36,7 +36,6 @@
  * @see JdbcResourceTransaction
  */
 public class JdbcResourceLocalTransactionCoordinatorImpl implements TransactionCoordinator {
-	private static final CoreMessageLogger log = messageLogger( JdbcResourceLocalTransactionCoordinatorImpl.class );
 
 	private final TransactionCoordinatorBuilder transactionCoordinatorBuilder;
 	private final JdbcResourceTransactionAccess jdbcResourceTransactionAccess;
@@ -92,7 +91,7 @@ public TransactionDriver getTransactionDriverControl() {
 	@Override
 	public void explicitJoin() {
 		// nothing to do here, but log a warning
-		log.callingJoinTransactionOnNonJtaEntityManager();
+		JDBC_MESSAGE_LOGGER.callingJoinTransactionOnNonJtaEntityManager();
 	}
 
 	@Override
@@ -151,7 +150,7 @@ private void afterBeginCallback() {
 		// report entering into a "transactional context"
 		transactionCoordinatorOwner.startTransactionBoundary();
 
-		log.trace( "Notifying resource-local transaction observers after begin" );
+		JDBC_LOGGER.trace( "Notifying resource-local transaction observers after begin" );
 
 		// trigger the Transaction-API-only after-begin callback
 		transactionCoordinatorOwner.afterTransactionBegin();
@@ -163,7 +162,7 @@ private void afterBeginCallback() {
 	}
 
 	private void beforeCompletionCallback() {
-		log.trace( "Notifying resource-local transaction observers before completion" );
+		JDBC_LOGGER.trace( "Notifying resource-local transaction observers before completion" );
 		try {
 			transactionCoordinatorOwner.beforeTransactionCompletion();
 			synchronizationRegistry.notifySynchronizationsBeforeTransactionCompletion();
@@ -181,7 +180,7 @@ private void beforeCompletionCallback() {
 	}
 
 	private void afterCompletionCallback(boolean successful) {
-		log.trace( "Notifying resource-local transaction observers after completion" );
+		JDBC_LOGGER.trace( "Notifying resource-local transaction observers after completion" );
 		final int statusToSend = successful ? Status.STATUS_COMMITTED : Status.STATUS_ROLLEDBACK;
 		synchronizationRegistry.notifySynchronizationsAfterTransactionCompletion( statusToSend );
 		transactionCoordinatorOwner.afterTransactionCompletion( successful, false );
@@ -231,7 +230,7 @@ public void begin() {
 
 		protected void errorIfInvalid() {
 			if ( invalid ) {
-				throw new IllegalStateException( "Physical-transaction delegate is no longer valid" );
+				throw new IllegalStateException( "Physical transaction delegate is no longer valid" );
 			}
 		}
 
@@ -263,14 +262,14 @@ private void commitNoRollbackOnly() {
 				}
 				catch (RuntimeException e2) {
 					e.addSuppressed( e2 );
-					log.debug( "Encountered failure rolling back failed commit", e2 );
+					JDBC_LOGGER.debug( "Encountered failure rolling back failed commit", e2 );
 				}
 				throw e;
 			}
 		}
 
 		private void commitRollbackOnly() {
-			log.trace( "On commit, transaction was marked for rollback only, rolling back" );
+			JDBC_LOGGER.trace( "On commit, transaction was marked for rollback only, rolling back" );
 			rollback();
 			if ( jpaCompliance.isJpaTransactionComplianceEnabled() ) {
 				throw new RollbackException( "Transaction was marked for rollback only" );
@@ -301,8 +300,8 @@ public TransactionStatus getStatus() {
 		@Override
 		public void markRollbackOnly() {
 			if ( getStatus() != TransactionStatus.ROLLED_BACK ) {
-				if ( log.isTraceEnabled() ) {
-					log.trace( "JDBC transaction marked for rollback only (exception provided for stack trace)",
+				if ( JDBC_LOGGER.isTraceEnabled() ) {
+					JDBC_LOGGER.trace( "JDBC transaction marked for rollback only (exception provided for stack trace)",
 							new Exception( "exception just for purpose of providing stack trace" ) );
 				}
 				rollbackOnly = true;

Original file line number	Diff line number	Diff line change
`@@ -138,4 +138,8 @@ public interface JdbcLogging extends BasicLogger {`
`138`	`138`	`JDBC version: %s.%s""",`
`139`	`139`	`id = 100018)`
`140`	`140`	`void logDriverInfo(String name, String version, int major, int minor, int jdbcMajor, int jdbcMinor);`
	`141`	`+`
	`142`	`+ @LogMessage(level = WARN)`
	`143`	`+ @Message(value = "Called joinTransaction() on a non-JTA EntityManager (ignoring)", id = 100020)`
	`144`	`+ void callingJoinTransactionOnNonJtaEntityManager();`
`141`	`145`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@`
`23`	`23`	`* @author Andrea Boriero`
`24`	`24`	`*/`
`25`	`25`	`public class JdbcIsolationDelegate implements IsolationDelegate {`
`26`		`- private static final CoreMessageLogger LOG = CoreLogging.messageLogger( JdbcIsolationDelegate.class );`
	`26`	`+ private static final CoreMessageLogger log = CoreLogging.messageLogger( JdbcIsolationDelegate.class );`
`27`	`27`
`28`	`28`	`private final JdbcConnectionAccess connectionAccess;`
`29`	`29`	`private final SqlExceptionHelper sqlExceptionHelper;`
`@@ -33,10 +33,7 @@ public JdbcIsolationDelegate(TransactionCoordinatorOwner transactionCoordinatorO`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`public JdbcIsolationDelegate(JdbcSessionOwner jdbcSessionOwner) {`
`36`		`- this(`
`37`		`- jdbcSessionOwner.getJdbcConnectionAccess(),`
`38`		`- jdbcSessionOwner.getSqlExceptionHelper()`
`39`		`- );`
	`36`	`+ this( jdbcSessionOwner.getJdbcConnectionAccess(), jdbcSessionOwner.getSqlExceptionHelper() );`
`40`	`37`	`}`
`41`	`38`
`42`	`39`	`public JdbcIsolationDelegate(JdbcConnectionAccess connectionAccess, SqlExceptionHelper sqlExceptionHelper) {`
`@@ -80,7 +77,7 @@ public <T> T delegateWork(WorkExecutorVisitable<T> work, boolean transacted) thr`
`80`	`77`	`}`
`81`	`78`	`}`
`82`	`79`	`catch ( Exception exception ) {`
`83`		`- LOG.unableToRollbackConnection( exception );`
	`80`	`+ log.unableToRollbackConnection( exception );`
`84`	`81`	`}`
`85`	`82`
`86`	`83`	`if ( e instanceof HibernateException ) {`
`@@ -99,14 +96,14 @@ else if ( e instanceof SQLException sqle ) {`
`99`	`96`	`connection.setAutoCommit( true );`
`100`	`97`	`}`
`101`	`98`	`catch ( Exception ignore ) {`
`102`		`- LOG.trace( "was unable to reset connection back to auto-commit" );`
	`99`	`+ log.trace( "Unable to reset connection back to auto-commit" );`
`103`	`100`	`}`
`104`	`101`	`}`
`105`	`102`	`try {`
`106`	`103`	`jdbcConnectionAccess().releaseConnection( connection );`
`107`	`104`	`}`
`108`	`105`	`catch ( Exception ignore ) {`
`109`		`- LOG.unableToReleaseIsolatedConnection( ignore );`
	`106`	`+ log.unableToReleaseIsolatedConnection( ignore );`
`110`	`107`	`}`
`111`	`108`	`}`
`112`	`109`	`}`