From 8d393c7a0b1e768b47c0e05ac70b72b9945dcd04 Mon Sep 17 00:00:00 2001 From: Gavin King Date: Sun, 14 Sep 2025 19:41:01 +0200 Subject: [PATCH 1/3] introduce JpaLogger --- .../hibernate/internal/CoreMessageLogger.java | 31 +-- .../jpa/HibernatePersistenceProvider.java | 107 +++++----- .../EntityManagerFactoryBuilderImpl.java | 14 +- .../PersistenceUnitInfoDescriptor.java | 7 +- .../jpa/boot/spi/PersistenceXmlParser.java | 10 +- .../jpa/boot/spi/ProviderChecker.java | 45 ++--- .../org/hibernate/jpa/internal/JpaLogger.java | 185 ++++++++++++++++++ .../internal/util/FlushModeTypeHelper.java | 11 +- .../jpa/internal/util/LogHelper.java | 140 ++++++------- .../DuplicatePersistenceUnitNameTest.java | 6 +- 10 files changed, 350 insertions(+), 206 deletions(-) create mode 100644 hibernate-core/src/main/java/org/hibernate/jpa/internal/JpaLogger.java diff --git a/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java b/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java index de9337266fbf..d6d8bab0a7b3 100644 --- a/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java +++ b/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java @@ -35,10 +35,10 @@ */ @SubSystemLogging( name = SessionLogging.NAME, - description = "Miscellaneous Logging related to Hibernate ORM Core" + description = "Miscellaneous logging related to Hibernate ORM Core" ) @MessageLogger(projectCode = "HHH") -@ValidIdRange(min=2,max = 10000) +@ValidIdRange(min=2,max = 8000) @Internal public interface CoreMessageLogger extends BasicLogger { @@ -59,10 +59,6 @@ public interface CoreMessageLogger extends BasicLogger { @Message(value = "Ignoring bag join fetch [%s] due to prior collection join fetch", id = 51) void containsJoinFetchedCollection(String role); - @LogMessage(level = WARN) - @Message(value = "Defining %s=true ignored in HEM", id = 59) - void definingFlushBeforeCompletionIgnoredInHem(String flushBeforeCompletion); - @LogMessage(level = WARN) @Message(value = "Entity [%s] is abstract-class/interface explicitly mapped as non-abstract; be sure to supply entity-names", id = 84) @@ -117,14 +113,6 @@ void missingArguments( id = 182) void noDefaultConstructor(String name); - @LogMessage(level = WARN) - @Message(value = "Overriding %s is dangerous, this might break the EJB3 specification implementation", id = 193) - void overridingTransactionStrategyDangerous(String transactionStrategy); - - @LogMessage(level = INFO) - @Message(value = "Processing PersistenceUnitInfo [name: %s]", id = 204) - void processingPersistenceUnitInfoName(String persistenceUnitName); - @LogMessage(level = INFO) @Message(value = "Loaded properties from resource hibernate.properties: %s", id = 205) void propertiesLoaded(Properties maskOut); @@ -220,10 +208,6 @@ void missingArguments( @Message(value = "Error creating schema ", id = 306) void unableToCreateSchema(@Cause Exception e); - @LogMessage(level = INFO) - @Message(value = "Could not find any META-INF/persistence.xml file in the classpath", id = 318) - void unableToFindPersistenceXmlInClasspath(); - @LogMessage(level = ERROR) @Message(value = "Problem loading properties from hibernate.properties", id = 329) void unableToLoadProperties(); @@ -369,10 +353,6 @@ void missingArguments( id = 513) void unableToGenerateReflectionOptimizer(String className, String cause); - @LogMessage(level = WARN) - @Message(value = "Failed to discover types for enhancement from class: %s", - id = 516) - void enhancementDiscoveryFailed(String className, @Cause Throwable cause); @LogMessage(level = DEBUG) @Message( id = 517, @@ -380,13 +360,6 @@ void missingArguments( ) void unusedMappedSuperclass(String name); - @LogMessage(level = WARN) - @Message( - id = 518, - value = "Encountered multiple persistence-unit stanzas defining same name [%s]; persistence-unit names must be unique" - ) - void duplicatedPersistenceUnitName(String name); - @LogMessage(level = WARN) @Message( id = 519, diff --git a/hibernate-core/src/main/java/org/hibernate/jpa/HibernatePersistenceProvider.java b/hibernate-core/src/main/java/org/hibernate/jpa/HibernatePersistenceProvider.java index 975cca067c0a..51f3b5b9fb3c 100644 --- a/hibernate-core/src/main/java/org/hibernate/jpa/HibernatePersistenceProvider.java +++ b/hibernate-core/src/main/java/org/hibernate/jpa/HibernatePersistenceProvider.java @@ -4,9 +4,7 @@ */ package org.hibernate.jpa; -import java.net.URL; import java.util.Collection; -import java.util.Collections; import java.util.List; import java.util.Map; import jakarta.persistence.EntityManagerFactory; @@ -23,10 +21,13 @@ import org.hibernate.jpa.boot.spi.Bootstrap; import org.hibernate.jpa.boot.spi.EntityManagerFactoryBuilder; import org.hibernate.jpa.boot.spi.PersistenceUnitDescriptor; -import org.hibernate.jpa.boot.spi.ProviderChecker; import org.hibernate.jpa.internal.util.PersistenceUtilHelper; +import org.hibernate.jpa.internal.util.PersistenceUtilHelper.MetadataCache; -import static org.hibernate.internal.CoreMessageLogger.CORE_LOGGER; +import static java.util.Collections.emptyMap; +import static java.util.Collections.unmodifiableMap; +import static org.hibernate.jpa.boot.spi.ProviderChecker.isProvider; +import static org.hibernate.jpa.internal.JpaLogger.JPA_LOGGER; /** * The best-ever implementation of a JPA {@link PersistenceProvider}. @@ -37,7 +38,7 @@ */ public class HibernatePersistenceProvider implements PersistenceProvider { - private final PersistenceUtilHelper.MetadataCache cache = new PersistenceUtilHelper.MetadataCache(); + private final MetadataCache cache = new MetadataCache(); /** * {@inheritDoc} @@ -46,13 +47,15 @@ public class HibernatePersistenceProvider implements PersistenceProvider { */ @Override public EntityManagerFactory createEntityManagerFactory(String persistenceUnitName, Map properties) { - CORE_LOGGER.tracef( "Starting createEntityManagerFactory for persistenceUnitName %s", persistenceUnitName ); - final EntityManagerFactoryBuilder builder = getEntityManagerFactoryBuilderOrNull( persistenceUnitName, properties ); + JPA_LOGGER.startingCreateEntityManagerFactory( persistenceUnitName ); + final var builder = getEntityManagerFactoryBuilderOrNull( persistenceUnitName, properties ); if ( builder == null ) { - CORE_LOGGER.trace( "Could not obtain matching EntityManagerFactoryBuilder, returning null" ); + JPA_LOGGER.couldNotObtainEmfBuilder("null"); return null; } - return builder.build(); + else { + return builder.build(); + } } protected EntityManagerFactoryBuilder getEntityManagerFactoryBuilderOrNull(String persistenceUnitName, Map properties) { @@ -71,22 +74,18 @@ protected EntityManagerFactoryBuilder getEntityManagerFactoryBuilderOrNull(Strin private EntityManagerFactoryBuilder getEntityManagerFactoryBuilderOrNull(String persistenceUnitName, Map properties, ClassLoader providedClassLoader, ClassLoaderService providedClassLoaderService) { - CORE_LOGGER.tracef( "Attempting to obtain correct EntityManagerFactoryBuilder for persistenceUnitName : %s", persistenceUnitName ); - - final Map integration = wrap( properties ); - final Collection units = locatePersistenceUnits( integration, providedClassLoader, providedClassLoaderService ); - - CORE_LOGGER.tracef( "Located and parsed %s persistence units; checking each", units.size() ); - + JPA_LOGGER.attemptingToObtainEmfBuilder( persistenceUnitName ); + final var integration = wrap( properties ); + final var units = locatePersistenceUnits( integration, providedClassLoader, providedClassLoaderService ); + JPA_LOGGER.locatedAndParsedPersistenceUnits( units.size() ); if ( persistenceUnitName == null && units.size() > 1 ) { - // no persistence-unit name to look for was given and we found multiple persistence-units + // no persistence-unit name was specified, and we found multiple persistence-units throw new PersistenceException( "No name provided and multiple persistence units found" ); } - for ( PersistenceUnitDescriptor persistenceUnit : units ) { - if ( CORE_LOGGER.isTraceEnabled() ) { - CORE_LOGGER.tracef( - "Checking persistence-unit [name=%s, explicit-provider=%s] against incoming persistence unit name [%s]", + for ( var persistenceUnit : units ) { + if ( JPA_LOGGER.isTraceEnabled() ) { + JPA_LOGGER.checkingPersistenceUnitName( persistenceUnit.getName(), persistenceUnit.getProviderClassName(), persistenceUnitName @@ -95,52 +94,47 @@ private EntityManagerFactoryBuilder getEntityManagerFactoryBuilderOrNull(String final boolean matches = persistenceUnitName == null || persistenceUnit.getName().equals( persistenceUnitName ); if ( !matches ) { - CORE_LOGGER.tracef( "Excluding from consideration due to name mismatch" ); + JPA_LOGGER.excludingDueToNameMismatch(); continue; } // See if we (Hibernate) are the persistence provider - if ( ! ProviderChecker.isProvider( persistenceUnit, properties ) ) { - CORE_LOGGER.tracef( "Excluding from consideration due to provider mismatch" ); + if ( !isProvider( persistenceUnit, properties ) ) { + JPA_LOGGER.excludingDueToProviderMismatch(); continue; } - if ( providedClassLoaderService != null ) { - return getEntityManagerFactoryBuilder( persistenceUnit, integration, providedClassLoaderService ); - } - else { - return getEntityManagerFactoryBuilder( persistenceUnit, integration, providedClassLoader ); - } + return providedClassLoaderService == null + ? getEntityManagerFactoryBuilder( persistenceUnit, integration, providedClassLoader ) + : getEntityManagerFactoryBuilder( persistenceUnit, integration, providedClassLoaderService ); } - CORE_LOGGER.debug( "Found no matching persistence units" ); + JPA_LOGGER.foundNoMatchingPersistenceUnits(); return null; } protected static Map wrap(Map properties) { - return properties == null ? Collections.emptyMap() : Collections.unmodifiableMap( properties ); + return properties == null ? emptyMap() : unmodifiableMap( properties ); } // Check before changing: may be overridden in Quarkus protected Collection locatePersistenceUnits(Map integration, ClassLoader providedClassLoader, ClassLoaderService providedClassLoaderService) { - final Collection units; try { var parser = PersistenceXmlParser.create( integration, providedClassLoader, providedClassLoaderService ); - final List xmlUrls = parser.getClassLoaderService().locateResources( "META-INF/persistence.xml" ); + final var xmlUrls = parser.getClassLoaderService().locateResources( "META-INF/persistence.xml" ); if ( xmlUrls.isEmpty() ) { - CORE_LOGGER.unableToFindPersistenceXmlInClasspath(); - units = List.of(); + JPA_LOGGER.unableToFindPersistenceXmlInClasspath(); + return List.of(); } else { - units = parser.parse( xmlUrls ).values(); + return parser.parse( xmlUrls ).values(); } } catch (Exception e) { - CORE_LOGGER.debug( "Unable to locate persistence units", e ); + JPA_LOGGER.unableToLocatePersistenceUnits( e ); throw new PersistenceException( "Unable to locate persistence units", e ); } - return units; } /** @@ -150,34 +144,28 @@ protected Collection locatePersistenceUnits(Map */ @Override public EntityManagerFactory createContainerEntityManagerFactory(PersistenceUnitInfo info, Map properties) { - if ( CORE_LOGGER.isTraceEnabled() ) { - CORE_LOGGER.tracef( "Starting createContainerEntityManagerFactory : %s", info.getPersistenceUnitName() ); - } - + JPA_LOGGER.startingCreateContainerEntityManagerFactory( info.getPersistenceUnitName() ); return getEntityManagerFactoryBuilder( info, properties ).build(); } @Override public void generateSchema(PersistenceUnitInfo info, Map map) { - if ( CORE_LOGGER.isTraceEnabled() ) { - CORE_LOGGER.tracef( "Starting generateSchema : PUI.name=%s", info.getPersistenceUnitName() ); - } - - final EntityManagerFactoryBuilder builder = getEntityManagerFactoryBuilder( info, map ); - builder.generateSchema(); + JPA_LOGGER.startingGenerateSchemaForPuiName( info.getPersistenceUnitName() ); + getEntityManagerFactoryBuilder( info, map ).generateSchema(); } @Override public boolean generateSchema(String persistenceUnitName, Map map) { - CORE_LOGGER.tracef( "Starting generateSchema for persistenceUnitName %s", persistenceUnitName ); - - final EntityManagerFactoryBuilder builder = getEntityManagerFactoryBuilderOrNull( persistenceUnitName, map ); + JPA_LOGGER.startingGenerateSchema( persistenceUnitName ); + final var builder = getEntityManagerFactoryBuilderOrNull( persistenceUnitName, map ); if ( builder == null ) { - CORE_LOGGER.trace( "Could not obtain matching EntityManagerFactoryBuilder, returning false" ); + JPA_LOGGER.couldNotObtainEmfBuilder("false"); return false; } - builder.generateSchema(); - return true; + else { + builder.generateSchema(); + return true; + } } protected EntityManagerFactoryBuilder getEntityManagerFactoryBuilder(PersistenceUnitInfo info, Map integration) { @@ -211,12 +199,15 @@ public LoadState isLoaded(Object object) { @Override public EntityManagerFactory createEntityManagerFactory(PersistenceConfiguration configuration) { - final EntityManagerFactoryBuilder builder = getEntityManagerFactoryBuilder( + return getEntityManagerFactoryBuilder( configuration ).build(); + } + + private EntityManagerFactoryBuilder getEntityManagerFactoryBuilder(PersistenceConfiguration configuration) { + return getEntityManagerFactoryBuilder( new PersistenceConfigurationDescriptor( configuration ), - Collections.emptyMap(), + emptyMap(), HibernatePersistenceProvider.class.getClassLoader() ); - return builder.build(); } @Override diff --git a/hibernate-core/src/main/java/org/hibernate/jpa/boot/internal/EntityManagerFactoryBuilderImpl.java b/hibernate-core/src/main/java/org/hibernate/jpa/boot/internal/EntityManagerFactoryBuilderImpl.java index 2642d8412124..0e8f88a90930 100644 --- a/hibernate-core/src/main/java/org/hibernate/jpa/boot/internal/EntityManagerFactoryBuilderImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/jpa/boot/internal/EntityManagerFactoryBuilderImpl.java @@ -107,7 +107,7 @@ import static org.hibernate.cfg.BytecodeSettings.ENHANCER_ENABLE_DIRTY_TRACKING; import static org.hibernate.cfg.BytecodeSettings.ENHANCER_ENABLE_LAZY_INITIALIZATION; import static org.hibernate.cfg.TransactionSettings.FLUSH_BEFORE_COMPLETION; -import static org.hibernate.internal.CoreMessageLogger.CORE_LOGGER; +import static org.hibernate.jpa.internal.JpaLogger.JPA_LOGGER; import static org.hibernate.internal.log.DeprecationLogger.DEPRECATION_LOGGER; import static org.hibernate.internal.util.NullnessHelper.coalesceSuppliedValues; import static org.hibernate.internal.util.StringHelper.isEmpty; @@ -264,7 +264,7 @@ private static void ignoreFlushBeforeCompletion(MergedSettings mergedSettings) { // flush before completion validation final var config = mergedSettings.getConfigurationValues(); if ( getBoolean( FLUSH_BEFORE_COMPLETION, config, false ) ) { - CORE_LOGGER.definingFlushBeforeCompletionIgnoredInHem( FLUSH_BEFORE_COMPLETION ); + JPA_LOGGER.definingFlushBeforeCompletionIgnoredInHem( FLUSH_BEFORE_COMPLETION ); config.put( FLUSH_BEFORE_COMPLETION, String.valueOf(false) ); } } @@ -348,7 +348,7 @@ private static void discoverTypesToTransform( classTransformer.discoverTypes(classLoader, className ); } catch (EnhancementException ex) { - CORE_LOGGER.enhancementDiscoveryFailed( className, ex ); + JPA_LOGGER.enhancementDiscoveryFailed( className, ex ); } } } @@ -800,7 +800,7 @@ private void normalizeTransactionCoordinator( } private static boolean handeTransactionCoordinatorStrategy(MergedSettings mergedSettings) { - CORE_LOGGER.overridingTransactionStrategyDangerous( TRANSACTION_COORDINATOR_STRATEGY ); + JPA_LOGGER.overridingTransactionStrategyDangerous( TRANSACTION_COORDINATOR_STRATEGY ); // see if we can tell whether it is a JTA coordinator final Object strategy = mergedSettings.getConfigurationValues().get( TRANSACTION_COORDINATOR_STRATEGY ); return strategy instanceof TransactionCoordinatorBuilder transactionCoordinatorBuilder @@ -821,7 +821,7 @@ private static PersistenceUnitTransactionType determineTransactionType( final var txnType = configuredTransactionType( persistenceUnit, integrationSettingsCopy, mergedSettings ); if ( txnType == null ) { // is it more appropriate to have this be based on bootstrap entry point (EE vs SE)? - CORE_LOGGER.debug( "PersistenceUnitTransactionType not specified - falling back to RESOURCE_LOCAL" ); + JPA_LOGGER.fallingBackToResourceLocal(); return PersistenceUnitTransactionType.RESOURCE_LOCAL; } else { @@ -1120,12 +1120,12 @@ private void cleanUpConfigKeys(Map integrationSettingsCopy, MergedSettings for ( String key : keys ) { final Object removedSetting = integrationSettingsCopy.remove( key ); if ( removedSetting != null ) { - CORE_LOGGER.debugf( "Removed integration override setting [%s] due to normalization", key ); + JPA_LOGGER.removedIntegrationOverride( key ); } final Object removedMergedSetting = mergedSettings.getConfigurationValues().remove( key ); if ( removedMergedSetting != null ) { - CORE_LOGGER.debugf( "Removed merged setting [%s] due to normalization", key ); + JPA_LOGGER.removedMergedSetting( key ); } } } diff --git a/hibernate-core/src/main/java/org/hibernate/jpa/boot/internal/PersistenceUnitInfoDescriptor.java b/hibernate-core/src/main/java/org/hibernate/jpa/boot/internal/PersistenceUnitInfoDescriptor.java index 79fc34a5698b..5ff760f5535c 100644 --- a/hibernate-core/src/main/java/org/hibernate/jpa/boot/internal/PersistenceUnitInfoDescriptor.java +++ b/hibernate-core/src/main/java/org/hibernate/jpa/boot/internal/PersistenceUnitInfoDescriptor.java @@ -21,7 +21,7 @@ import org.hibernate.jpa.internal.util.PersistenceUnitTransactionTypeHelper; -import static org.hibernate.internal.CoreMessageLogger.CORE_LOGGER; +import static org.hibernate.jpa.internal.JpaLogger.JPA_LOGGER; /** * @author Steve Ebersole @@ -130,9 +130,8 @@ public void pushClassTransformer(EnhancementContext enhancementContext) { // During testing, we will return a null temp class loader // in cases where we don't care about enhancement if ( persistenceUnitInfo.getNewTempClassLoader() != null ) { - if ( CORE_LOGGER.isTraceEnabled() ) { - CORE_LOGGER.trace( "Pushing class transformers for PU named '" + getName() - + "' on loading classloader " + enhancementContext.getLoadingClassLoader() ); + if ( JPA_LOGGER.isTraceEnabled() ) { + JPA_LOGGER.pushingClassTransformers( getName(), String.valueOf( enhancementContext.getLoadingClassLoader() ) ); } final EnhancingClassTransformerImpl classTransformer = new EnhancingClassTransformerImpl( enhancementContext ); diff --git a/hibernate-core/src/main/java/org/hibernate/jpa/boot/spi/PersistenceXmlParser.java b/hibernate-core/src/main/java/org/hibernate/jpa/boot/spi/PersistenceXmlParser.java index 8153ea81b5c3..772c67bcf017 100644 --- a/hibernate-core/src/main/java/org/hibernate/jpa/boot/spi/PersistenceXmlParser.java +++ b/hibernate-core/src/main/java/org/hibernate/jpa/boot/spi/PersistenceXmlParser.java @@ -40,7 +40,7 @@ import static jakarta.persistence.PersistenceUnitTransactionType.JTA; import static jakarta.persistence.PersistenceUnitTransactionType.RESOURCE_LOCAL; -import static org.hibernate.internal.CoreMessageLogger.CORE_LOGGER; +import static org.hibernate.jpa.internal.JpaLogger.JPA_LOGGER; import static org.hibernate.internal.util.StringHelper.isEmpty; /** @@ -158,8 +158,8 @@ private void parsePersistenceXml(Map persiste private void parsePersistenceXml(Map persistenceUnits, URL xmlUrl, PersistenceUnitTransactionType defaultTransactionType) { - if ( CORE_LOGGER.isTraceEnabled() ) { - CORE_LOGGER.tracef( "Attempting to parse persistence.xml file : %s", xmlUrl.toExternalForm() ); + if ( JPA_LOGGER.isTraceEnabled() ) { + JPA_LOGGER.attemptingToParsePersistenceXml( xmlUrl.toExternalForm() ); } final URL persistenceUnitRootUrl = ArchiveHelper.getJarURLFromURLEntry( xmlUrl, "/META-INF/persistence.xml" ); @@ -171,7 +171,7 @@ private void parsePersistenceXml(Map persiste final JaxbPersistenceUnitImpl jaxbPersistenceUnit = jaxbPersistenceUnits.get( i ); if ( persistenceUnits.containsKey( jaxbPersistenceUnit.getName() ) ) { - CORE_LOGGER.duplicatedPersistenceUnitName( jaxbPersistenceUnit.getName() ); + JPA_LOGGER.duplicatedPersistenceUnitName( jaxbPersistenceUnit.getName() ); continue; } @@ -192,7 +192,7 @@ private void bindPersistenceUnit( ParsedPersistenceXmlDescriptor persistenceUnitDescriptor) { final String name = jaxbPersistenceUnit.getName(); if ( StringHelper.isNotEmpty( name ) ) { - CORE_LOGGER.tracef( "Persistence unit name from persistence.xml : %s", name ); + JPA_LOGGER.persistenceUnitNameFromXml( name ); persistenceUnitDescriptor.setName( name ); } diff --git a/hibernate-core/src/main/java/org/hibernate/jpa/boot/spi/ProviderChecker.java b/hibernate-core/src/main/java/org/hibernate/jpa/boot/spi/ProviderChecker.java index fa649699da25..436f8d95f4ac 100644 --- a/hibernate-core/src/main/java/org/hibernate/jpa/boot/spi/ProviderChecker.java +++ b/hibernate-core/src/main/java/org/hibernate/jpa/boot/spi/ProviderChecker.java @@ -7,11 +7,13 @@ import java.util.Map; import org.hibernate.cfg.AvailableSettings; -import org.hibernate.internal.log.DeprecationLogger; import org.hibernate.internal.util.NullnessHelper; import org.hibernate.jpa.HibernatePersistenceProvider; -import org.jboss.logging.Logger; +import static org.hibernate.cfg.PersistenceSettings.JAKARTA_PERSISTENCE_PROVIDER; +import static org.hibernate.cfg.PersistenceSettings.JPA_PERSISTENCE_PROVIDER; +import static org.hibernate.jpa.internal.JpaLogger.JPA_LOGGER; +import static org.hibernate.internal.log.DeprecationLogger.DEPRECATION_LOGGER; /** * Helper for handling checks to see whether Hibernate is the requested @@ -21,14 +23,12 @@ */ public final class ProviderChecker { - private static final Logger LOG = Logger.getLogger( ProviderChecker.class ); - /** * Does the descriptor and/or integration request Hibernate as the * {@link jakarta.persistence.spi.PersistenceProvider}? - * - * Note that in the case of no requested provider being named we assume we are the - * provider (the calls got to us somehow...) + *

+ * Note that in the case of no requested provider being named, we + * assume we are the provider. (The calls got to us somehow...) * * @param persistenceUnit The {@code } descriptor. * @param integration The integration values. @@ -48,10 +48,7 @@ public static boolean isProvider(PersistenceUnitDescriptor persistenceUnit, Map * @return {@code true} if Hibernate should be the provider; {@code false} otherwise. */ public static boolean hibernateProviderNamesContain(String requestedProviderName) { - LOG.tracef( - "Checking requested PersistenceProvider name [%s] against Hibernate provider names", - requestedProviderName - ); + JPA_LOGGER.checkingRequestedPersistenceProviderName( requestedProviderName ); return HibernatePersistenceProvider.class.getName().equals( requestedProviderName ); } @@ -69,24 +66,21 @@ public static boolean hibernateProviderNamesContain(String requestedProviderName public static String extractRequestedProviderName(PersistenceUnitDescriptor persistenceUnit, Map integration) { final String integrationProviderName = extractProviderName( integration ); if ( integrationProviderName != null ) { - LOG.debugf( "Integration provided explicit PersistenceProvider [%s]", integrationProviderName ); + JPA_LOGGER.integrationProvidedExplicitPersistenceProvider( integrationProviderName ); return integrationProviderName; } final String persistenceUnitRequestedProvider = extractProviderName( persistenceUnit ); if ( persistenceUnitRequestedProvider != null ) { - if ( LOG.isDebugEnabled() ) { - LOG.debugf( - "Persistence-unit [%s] requested PersistenceProvider [%s]", - persistenceUnit.getName(), - persistenceUnitRequestedProvider - ); - } + JPA_LOGGER.persistenceUnitRequestedPersistenceProvider( + persistenceUnit.getName(), + persistenceUnitRequestedProvider + ); return persistenceUnitRequestedProvider; } // NOTE: if no provider requested, we assume we are the provider (the calls got to us somehow...) - LOG.debug( "No PersistenceProvider explicitly requested, assuming Hibernate" ); + JPA_LOGGER.noPersistenceProviderExplicitlySpecified(); return HibernatePersistenceProvider.class.getName(); } @@ -96,14 +90,13 @@ private static String extractProviderName(Map integration) { } final String setting = NullnessHelper.coalesceSuppliedValues( - () -> (String) integration.get(AvailableSettings.JAKARTA_PERSISTENCE_PROVIDER ), + () -> (String) integration.get( JAKARTA_PERSISTENCE_PROVIDER ), () -> { - final String value = (String) integration.get( AvailableSettings.JPA_PERSISTENCE_PROVIDER ); + final String value = (String) integration.get( JPA_PERSISTENCE_PROVIDER ); if ( value != null ) { - DeprecationLogger.DEPRECATION_LOGGER.deprecatedSetting( - AvailableSettings.JPA_PERSISTENCE_PROVIDER, - AvailableSettings.JAKARTA_PERSISTENCE_PROVIDER - ); + DEPRECATION_LOGGER.deprecatedSetting( + JPA_PERSISTENCE_PROVIDER, + JAKARTA_PERSISTENCE_PROVIDER ); } return value; } diff --git a/hibernate-core/src/main/java/org/hibernate/jpa/internal/JpaLogger.java b/hibernate-core/src/main/java/org/hibernate/jpa/internal/JpaLogger.java new file mode 100644 index 000000000000..9024e217f5bc --- /dev/null +++ b/hibernate-core/src/main/java/org/hibernate/jpa/internal/JpaLogger.java @@ -0,0 +1,185 @@ +/* + * SPDX-License-Identifier: Apache-2.0 + * Copyright Red Hat Inc. and Hibernate Authors + */ +package org.hibernate.jpa.internal; + +import org.hibernate.Internal; +import org.hibernate.internal.SessionLogging; +import org.hibernate.internal.log.SubSystemLogging; +import org.jboss.logging.BasicLogger; +import org.jboss.logging.Logger; +import org.jboss.logging.annotations.Cause; +import org.jboss.logging.annotations.LogMessage; +import org.jboss.logging.annotations.Message; +import org.jboss.logging.annotations.MessageLogger; +import org.jboss.logging.annotations.ValidIdRange; + +import java.lang.invoke.MethodHandles; + +import static org.jboss.logging.Logger.Level.DEBUG; +import static org.jboss.logging.Logger.Level.INFO; +import static org.jboss.logging.Logger.Level.TRACE; +import static org.jboss.logging.Logger.Level.WARN; + +/** + * Miscellaneous logging related to Jakarta Persistence compatibility. + */ +@SubSystemLogging( + name = SessionLogging.NAME, + description = "Logging related to Jakarta Persistence compatibility" +) +@MessageLogger(projectCode = "HHH") +@ValidIdRange(min=8001,max = 10000) +@Internal +public interface JpaLogger extends BasicLogger { + + String NAME = SubSystemLogging.BASE + ".jpa"; + + JpaLogger JPA_LOGGER = Logger.getMessageLogger( MethodHandles.lookup(), JpaLogger.class, NAME ); + + @LogMessage(level = WARN) + @Message(value = "Defining %s=true ignored in HEM", id = 8059) + void definingFlushBeforeCompletionIgnoredInHem(String flushBeforeCompletion); + + @LogMessage(level = WARN) + @Message(id = 8193, value = "Overriding %s is dangerous, this might break the JPA specification implementation") + void overridingTransactionStrategyDangerous(String transactionStrategy); + + @LogMessage(level = INFO) + @Message(id = 8318, value = "Could not find any META-INF/persistence.xml file in the classpath") + void unableToFindPersistenceXmlInClasspath(); + + @LogMessage(level = WARN) + @Message( + id = 8518, + value = "Encountered multiple persistence-unit stanzas defining same name [%s]; persistence-unit names must be unique" + ) + void duplicatedPersistenceUnitName(String name); + + @LogMessage(level = WARN) + @Message(id = 8516, value = "Failed to discover types for enhancement from class: %s") + void enhancementDiscoveryFailed(String className, @Cause Throwable cause); + + @LogMessage(level = DEBUG) + @Message(id = 8520, value = "Removed integration override setting [%s] due to normalization") + void removedIntegrationOverride(String key); + + @LogMessage(level = DEBUG) + @Message(id = 8521, value = "Removed merged setting [%s] due to normalization") + void removedMergedSetting(String key); + + @LogMessage(level = TRACE) + @Message(id = 8522, value = "Starting createEntityManagerFactory for persistenceUnitName %s") + void startingCreateEntityManagerFactory(String persistenceUnitName); + + @LogMessage(level = TRACE) + @Message(id = 8523, value = "Could not obtain matching EntityManagerFactoryBuilder, returning %s") + void couldNotObtainEmfBuilder(String result); + + @LogMessage(level = TRACE) + @Message(id = 8524, value = "Attempting to obtain correct EntityManagerFactoryBuilder for persistenceUnitName : %s") + void attemptingToObtainEmfBuilder(String persistenceUnitName); + + @LogMessage(level = TRACE) + @Message(id = 8525, value = "Located and parsed %s persistence units; checking each") + void locatedAndParsedPersistenceUnits(int count); + + @LogMessage(level = TRACE) + @Message(id = 8526, value = "Checking persistence-unit [name=%s, explicit-provider=%s] against incoming persistence unit name [%s]") + void checkingPersistenceUnitName(String name, String explicitProvider, String incomingName); + + @LogMessage(level = TRACE) + @Message(id = 8527, value = "Excluding from consideration due to name mismatch") + void excludingDueToNameMismatch(); + + @LogMessage(level = TRACE) + @Message(id = 8528, value = "Excluding from consideration due to provider mismatch") + void excludingDueToProviderMismatch(); + + @LogMessage(level = DEBUG) + @Message(id = 8529, value = "Found no matching persistence units") + void foundNoMatchingPersistenceUnits(); + + @LogMessage(level = DEBUG) + @Message(id = 8530, value = "Unable to locate persistence units") + void unableToLocatePersistenceUnits(@Cause Throwable t); + + @LogMessage(level = TRACE) + @Message(id = 8531, value = "Starting createContainerEntityManagerFactory : %s") + void startingCreateContainerEntityManagerFactory(String name); + + @LogMessage(level = TRACE) + @Message(id = 8532, value = "Starting generateSchema : PUI.name=%s") + void startingGenerateSchemaForPuiName(String name); + + @LogMessage(level = TRACE) + @Message(id = 8533, value = "Starting generateSchema for persistenceUnitName %s") + void startingGenerateSchema(String name); + + @LogMessage(level = TRACE) + @Message(id = 8535, value = "Attempting to parse persistence.xml file : %s") + void attemptingToParsePersistenceXml(String url); + + @LogMessage(level = TRACE) + @Message(id = 8536, value = "Persistence unit name from persistence.xml: '%s'") + void persistenceUnitNameFromXml(String name); + + @LogMessage(level = TRACE) + @Message(id = 8537, value = "Pushing class transformers for PU named '%s' on loading classloader %s") + void pushingClassTransformers(String persistenceUnitName, String loadingClassLoader); + + @LogMessage(level = DEBUG) + @Message(id = 8538, value = "PersistenceUnitTransactionType defaulting to RESOURCE_LOCAL") + void fallingBackToResourceLocal(); + + @LogMessage(level = INFO) + @Message(id = 8540, value = "Processing PersistenceUnitInfo [name: %s]") + void processingPersistenceUnitInfo(String persistenceUnitName); + + @LogMessage(level = DEBUG) + @Message(id = 8541, value = "%s") + void processingPersistenceUnitInfoDetails(String string); + + // ProviderChecker + + @LogMessage(level = TRACE) + @Message(id = 8542, value = "Checking requested PersistenceProvider name [%s] against Hibernate provider names") + void checkingRequestedPersistenceProviderName(String requestedProviderName); + + @LogMessage(level = DEBUG) + @Message(id = 8543, value = "Integration provided explicit PersistenceProvider [%s]") + void integrationProvidedExplicitPersistenceProvider(String providerName); + + @LogMessage(level = DEBUG) + @Message(id = 8544, value = "Persistence-unit [%s] requested PersistenceProvider [%s]") + void persistenceUnitRequestedPersistenceProvider(String persistenceUnitName, String providerName); + + @LogMessage(level = DEBUG) + @Message(id = 8545, value = "No PersistenceProvider explicitly requested, assuming Hibernate") + void noPersistenceProviderExplicitlySpecified(); + + // FlushModeTypeHelper + + @LogMessage(level = DEBUG) + @Message(id = 8546, + value = """ + Interpreting Hibernate 'FlushMode.ALWAYS' as JPA 'FlushModeType.AUTO'\ + (may cause problems if relying on FlushMode.ALWAYS-specific behavior)""") + void interpretingFlushModeAlwaysAsJpaAuto(); + + @LogMessage(level = DEBUG) + @Message(id = 8547, + value = """ + Interpreting Hibernate 'FlushMode.MANUAL' as JPA 'FlushModeType.COMMIT'\ + (may cause problems if relying on FlushMode.MANUAL-specific behavior)""") + void interpretingFlushModeManualAsJpaCommit(); + + @LogMessage(level = TRACE) + @Message(id = 8548, value = "Attempting to interpret external setting [%s] as FlushMode name") + void attemptingToInterpretExternalSettingAsFlushModeName(String externalName); + + @LogMessage(level = TRACE) + @Message(id = 8549, value = "Attempting to interpret external setting [%s] as FlushModeType name") + void attemptingToInterpretExternalSettingAsFlushModeTypeName(String externalName); +} diff --git a/hibernate-core/src/main/java/org/hibernate/jpa/internal/util/FlushModeTypeHelper.java b/hibernate-core/src/main/java/org/hibernate/jpa/internal/util/FlushModeTypeHelper.java index 3e33ba4573ee..1e8ac945f7da 100644 --- a/hibernate-core/src/main/java/org/hibernate/jpa/internal/util/FlushModeTypeHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/jpa/internal/util/FlushModeTypeHelper.java @@ -12,7 +12,7 @@ import org.hibernate.query.QueryFlushMode; import org.hibernate.MappingException; -import org.jboss.logging.Logger; +import static org.hibernate.jpa.internal.JpaLogger.JPA_LOGGER; /** * Helper to deal with conversions between {@link FlushModeType} and {@link FlushMode}. @@ -20,7 +20,6 @@ * @author Steve Ebersole */ public class FlushModeTypeHelper { - private static final Logger LOG = Logger.getLogger( FlushModeTypeHelper.class ); private FlushModeTypeHelper() { } @@ -31,11 +30,11 @@ public static FlushModeType getFlushModeType(FlushMode flushMode) { } return switch (flushMode) { case ALWAYS -> { - LOG.debug("Interpreting Hibernate FlushMode.ALWAYS as JPA FlushModeType.AUTO (may cause problems if relying on FlushMode.ALWAYS-specific behavior)"); + JPA_LOGGER.interpretingFlushModeAlwaysAsJpaAuto(); yield FlushModeType.AUTO; } case MANUAL -> { - LOG.debug("Interpreting Hibernate FlushMode.MANUAL as JPA FlushModeType.COMMIT (may cause problems if relying on FlushMode.MANUAL-specific behavior)"); + JPA_LOGGER.interpretingFlushModeManualAsJpaCommit(); yield FlushModeType.COMMIT; } case COMMIT -> FlushModeType.COMMIT; @@ -101,11 +100,11 @@ public static FlushMode interpretExternalSetting(String externalName) { } try { - LOG.tracef( "Attempting to interpret external setting [%s] as FlushMode name", externalName ); + JPA_LOGGER.attemptingToInterpretExternalSettingAsFlushModeName( externalName ); return FlushMode.valueOf( externalName.toUpperCase( Locale.ROOT) ); } catch ( IllegalArgumentException e ) { - LOG.tracef( "Attempting to interpret external setting [%s] as FlushModeType name", externalName ); + JPA_LOGGER.attemptingToInterpretExternalSettingAsFlushModeTypeName( externalName ); } try { diff --git a/hibernate-core/src/main/java/org/hibernate/jpa/internal/util/LogHelper.java b/hibernate-core/src/main/java/org/hibernate/jpa/internal/util/LogHelper.java index 515a89f54d50..49ff20cc9911 100644 --- a/hibernate-core/src/main/java/org/hibernate/jpa/internal/util/LogHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/jpa/internal/util/LogHelper.java @@ -11,7 +11,7 @@ import org.hibernate.jpa.boot.spi.PersistenceUnitDescriptor; -import static org.hibernate.internal.CoreMessageLogger.CORE_LOGGER; +import static org.hibernate.jpa.internal.JpaLogger.JPA_LOGGER; /** @@ -24,78 +24,82 @@ private LogHelper() { } public static void logPersistenceUnitInformation(PersistenceUnitDescriptor descriptor) { - if ( ! CORE_LOGGER.isDebugEnabled() ) { - CORE_LOGGER.processingPersistenceUnitInfoName( descriptor.getName() ); - return; - } + if ( JPA_LOGGER.isDebugEnabled() ) { + final var builder = new StringBuilder(); + builder.append( "PersistenceUnitInfo [\n\t" ) + .append( "name: " ) + .append( descriptor.getName() ) + .append( "\n\t" ) + .append( "persistence provider classname: " ) + .append( descriptor.getProviderClassName() ) + .append( "\n\t" ) + .append( "classloader: " ) + .append( descriptor.getClassLoader() ) + .append( "\n\t" ) + .append( "excludeUnlistedClasses: " ) + .append( descriptor.isExcludeUnlistedClasses() ) + .append( "\n\t" ) + .append( "JTA datasource: " ) + .append( descriptor.getJtaDataSource() ) + .append( "\n\t" ) + .append( "Non JTA datasource: " ) + .append( descriptor.getNonJtaDataSource() ) + .append( "\n\t" ) + .append( "Transaction type: " ) + .append( descriptor.getPersistenceUnitTransactionType() ) + .append( "\n\t" ) + .append( "PU root URL: " ) + .append( descriptor.getPersistenceUnitRootUrl() ) + .append( "\n\t" ) + .append( "Shared Cache Mode: " ) + .append( descriptor.getSharedCacheMode() ) + .append( "\n\t" ) + .append( "Validation Mode: " ) + .append( descriptor.getValidationMode() ) + .append( "\n\t" ); - StringBuilder sb = new StringBuilder(); - sb.append( "PersistenceUnitInfo [\n\t" ) - .append( "name: " ) - .append( descriptor.getName() ) - .append( "\n\t" ) - .append( "persistence provider classname: " ) - .append( descriptor.getProviderClassName() ) - .append( "\n\t" ) - .append( "classloader: " ) - .append( descriptor.getClassLoader() ) - .append( "\n\t" ) - .append( "excludeUnlistedClasses: " ) - .append( descriptor.isExcludeUnlistedClasses() ) - .append( "\n\t" ) - .append( "JTA datasource: " ) - .append( descriptor.getJtaDataSource() ) - .append( "\n\t" ) - .append( "Non JTA datasource: " ) - .append( descriptor.getNonJtaDataSource() ) - .append( "\n\t" ) - .append( "Transaction type: " ) - .append( descriptor.getPersistenceUnitTransactionType() ) - .append( "\n\t" ) - .append( "PU root URL: " ) - .append( descriptor.getPersistenceUnitRootUrl() ) - .append( "\n\t" ) - .append( "Shared Cache Mode: " ) - .append( descriptor.getSharedCacheMode() ) - .append( "\n\t" ) - .append( "Validation Mode: " ) - .append( descriptor.getValidationMode() ) - .append( "\n\t" ); - sb.append( "Jar files URLs [" ); - List jarFileUrls = descriptor.getJarFileUrls(); - if ( jarFileUrls != null ) { - for ( URL url : jarFileUrls ) { - sb.append( "\n\t\t" ).append( url ); + builder.append( "Jar files URLs [" ); + List jarFileUrls = descriptor.getJarFileUrls(); + if ( jarFileUrls != null ) { + for ( URL url : jarFileUrls ) { + builder.append( "\n\t\t" ).append( url ); + } } - } - sb.append( "]\n\t" ); - sb.append( "Managed classes names [" ); - List classNames = descriptor.getManagedClassNames(); - if ( classNames != null ) { - for ( String className : classNames ) { - sb.append( "\n\t\t" ).append( className ); + builder.append( "]\n\t" ); + + builder.append( "Managed classes names [" ); + List classNames = descriptor.getManagedClassNames(); + if ( classNames != null ) { + for ( String className : classNames ) { + builder.append( "\n\t\t" ).append( className ); + } } - } - sb.append( "]\n\t" ); - sb.append( "Mapping files names [" ); - List mappingFiles = descriptor.getMappingFileNames(); - if ( mappingFiles != null ) { - for ( String file : mappingFiles ) { - sb.append( "\n\t\t" ).append( file ); + builder.append( "]\n\t" ); + + builder.append( "Mapping files names [" ); + List mappingFiles = descriptor.getMappingFileNames(); + if ( mappingFiles != null ) { + for ( String file : mappingFiles ) { + builder.append( "\n\t\t" ).append( file ); + } } - } - sb.append( "]\n\t" ); - sb.append( "Properties [" ); - Properties properties = descriptor.getProperties(); - if (properties != null) { - Enumeration names = properties.propertyNames(); - while ( names.hasMoreElements() ) { - String name = (String) names.nextElement(); - sb.append( "\n\t\t" ).append( name ).append( ": " ).append( properties.getProperty( name ) ); + builder.append( "]\n\t" ); + + builder.append( "Properties [" ); + Properties properties = descriptor.getProperties(); + if ( properties != null ) { + Enumeration names = properties.propertyNames(); + while ( names.hasMoreElements() ) { + String name = (String) names.nextElement(); + builder.append( "\n\t\t" ).append( name ).append( ": " ).append( properties.getProperty( name ) ); + } } - } - sb.append( "]" ); + builder.append( "]" ); - CORE_LOGGER.debug( sb.toString() ); + JPA_LOGGER.processingPersistenceUnitInfoDetails( builder.toString() ); + } + else { + JPA_LOGGER.processingPersistenceUnitInfo( descriptor.getName() ); + } } } diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/jpa/persistenceunit/DuplicatePersistenceUnitNameTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/jpa/persistenceunit/DuplicatePersistenceUnitNameTest.java index cc3cce9e7f94..7c3566a66fc0 100644 --- a/hibernate-core/src/test/java/org/hibernate/orm/test/jpa/persistenceunit/DuplicatePersistenceUnitNameTest.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/jpa/persistenceunit/DuplicatePersistenceUnitNameTest.java @@ -19,8 +19,8 @@ import org.junit.Test; -import static org.hibernate.internal.CoreMessageLogger.CORE_LOGGER; import static org.hibernate.internal.util.ConfigHelper.findAsResource; +import static org.hibernate.jpa.internal.JpaLogger.JPA_LOGGER; import static org.junit.Assert.assertTrue; /** @@ -31,11 +31,11 @@ public class DuplicatePersistenceUnitNameTest extends BaseUnitTestCase { private Triggerable triggerable; @Rule - public LoggerInspectionRule logInspection = new LoggerInspectionRule( CORE_LOGGER ); + public LoggerInspectionRule logInspection = new LoggerInspectionRule( JPA_LOGGER ); @Before public void setUp() { - triggerable = logInspection.watchForLogMessages( Set.of( "HHH000518" ) ); + triggerable = logInspection.watchForLogMessages( Set.of( "HHH008518" ) ); } @After From 6531118427d4c49aab0aa1be1b005d8998bf12e6 Mon Sep 17 00:00:00 2001 From: Gavin King Date: Sun, 14 Sep 2025 20:03:11 +0200 Subject: [PATCH 2/3] typesafe logging in TemporaryTableHelper --- .../dialect/HANAServerConfiguration.java | 15 +++-- .../temptable/TemporaryTableHelper.java | 38 +++++-------- .../hibernate/internal/CoreMessageLogger.java | 55 +++++++++++++++---- 3 files changed, 67 insertions(+), 41 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/HANAServerConfiguration.java b/hibernate-core/src/main/java/org/hibernate/dialect/HANAServerConfiguration.java index e420182db362..f846cb90e90f 100644 --- a/hibernate-core/src/main/java/org/hibernate/dialect/HANAServerConfiguration.java +++ b/hibernate-core/src/main/java/org/hibernate/dialect/HANAServerConfiguration.java @@ -15,9 +15,9 @@ import org.hibernate.engine.jdbc.dialect.spi.DialectResolutionInfo; import org.hibernate.internal.util.StringHelper; import org.hibernate.internal.util.config.ConfigurationHelper; +import org.jboss.logging.Logger; import static org.hibernate.cfg.DialectSpecificSettings.HANA_MAX_LOB_PREFETCH_SIZE; -import static org.hibernate.internal.CoreMessageLogger.CORE_LOGGER; /** * Utility class that extracts some initial configuration from the database for {@link HANADialect}. @@ -58,9 +58,8 @@ public static HANAServerConfiguration fromDialectResolutionInfo(DialectResolutio } catch (SQLException e) { // Ignore - CORE_LOGGER.debug( - "An error occurred while trying to determine the database version.", - e ); + Logger.getLogger( HANAServerConfiguration.class ) + .debug( "An error occurred while trying to determine the database version.", e ); } if (databaseMajorVersion > 0 && databaseMajorVersion < 4) { @@ -75,9 +74,8 @@ public static HANAServerConfiguration fromDialectResolutionInfo(DialectResolutio } catch (SQLException e) { // Ignore - CORE_LOGGER.debug( - "An error occurred while trying to determine the value of the HANA parameter indexserver.ini / session / max_lob_prefetch_size.", - e ); + Logger.getLogger( HANAServerConfiguration.class ) + .debug( "An error occurred while trying to determine the value of the HANA parameter indexserver.ini / session / max_lob_prefetch_size", e ); } } else { @@ -113,7 +111,8 @@ public static DatabaseVersion determineDatabaseVersion(DialectResolutionInfo inf } catch (SQLException e) { // Ignore - CORE_LOGGER.debug( "An error occurred while trying to determine the HANA Cloud version.", e ); + Logger.getLogger( HANAServerConfiguration.class ) + .debug( "An error occurred while trying to determine the HANA Cloud version.", e ); } } return databaseVersion == null diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/temptable/TemporaryTableHelper.java b/hibernate-core/src/main/java/org/hibernate/dialect/temptable/TemporaryTableHelper.java index 0fc5ffa4f607..03826fda12b8 100644 --- a/hibernate-core/src/main/java/org/hibernate/dialect/temptable/TemporaryTableHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/dialect/temptable/TemporaryTableHelper.java @@ -8,14 +8,11 @@ import java.sql.PreparedStatement; import java.sql.SQLException; import java.sql.SQLWarning; -import java.sql.Statement; import java.util.function.Function; import org.hibernate.engine.jdbc.internal.FormatStyle; -import org.hibernate.engine.jdbc.spi.JdbcCoordinator; import org.hibernate.engine.jdbc.spi.JdbcServices; import org.hibernate.engine.jdbc.spi.SqlExceptionHelper; -import org.hibernate.engine.jdbc.spi.SqlStatementLogger; import org.hibernate.engine.spi.SessionFactoryImplementor; import org.hibernate.engine.spi.SharedSessionContractImplementor; import org.hibernate.jdbc.AbstractReturningWork; @@ -59,28 +56,25 @@ public TemporaryTableCreationWork( @Override public Boolean execute(Connection connection) { - final JdbcServices jdbcServices = sessionFactory.getJdbcServices(); - + final var jdbcServices = sessionFactory.getJdbcServices(); try { final String creationCommand = exporter.getSqlCreateCommand( temporaryTable ); logStatement( creationCommand, jdbcServices ); - - try (Statement statement = connection.createStatement()) { + try ( var statement = connection.createStatement() ) { statement.executeUpdate( creationCommand ); jdbcServices.getSqlExceptionHelper().handleAndClearWarnings( statement, WARNING_HANDLER ); return Boolean.TRUE; } catch (SQLException e) { - CORE_LOGGER.debugf( - "Unable to create temporary table [%s]; `%s` failed : %s", + CORE_LOGGER.unableToCreateTempTable( temporaryTable.getQualifiedTableName(), creationCommand, - e.getMessage() + e ); } } catch( Exception e ) { - CORE_LOGGER.debugf( "Error creating temporary table(s) : %s", e.getMessage() ); + CORE_LOGGER.errorCreatingTempTable( e ); } return Boolean.FALSE; } @@ -116,27 +110,25 @@ public TemporaryTableDropWork( @Override public void execute(Connection connection) { - final JdbcServices jdbcServices = sessionFactory.getJdbcServices(); - + final var jdbcServices = sessionFactory.getJdbcServices(); try { final String dropCommand = exporter.getSqlDropCommand( temporaryTable ); logStatement( dropCommand, jdbcServices ); - - try (Statement statement = connection.createStatement()) { + try ( var statement = connection.createStatement() ) { statement.executeUpdate( dropCommand ); - jdbcServices.getSqlExceptionHelper().handleAndClearWarnings( statement, WARNING_HANDLER ); + jdbcServices.getSqlExceptionHelper() + .handleAndClearWarnings( statement, WARNING_HANDLER ); } catch (SQLException e) { - CORE_LOGGER.debugf( - "Unable to drop temporary table [%s]; `%s` failed : %s", + CORE_LOGGER.unableToDropTempTable( temporaryTable.getQualifiedTableName(), dropCommand, - e.getMessage() + e ); } } catch( Exception e ) { - CORE_LOGGER.debugf( "Error dropping temporary table(s) : %s", e.getMessage() ); + CORE_LOGGER.errorDroppingTempTable( e ); } } } @@ -150,7 +142,7 @@ public static void cleanTemporaryTableRows( TemporaryTableExporter exporter, Function sessionUidAccess, SharedSessionContractImplementor session) { - final JdbcCoordinator jdbcCoordinator = session.getJdbcCoordinator(); + final var jdbcCoordinator = session.getJdbcCoordinator(); PreparedStatement preparedStatement = null; try { final String sql = exporter.getSqlTruncateCommand( temporaryTable, sessionUidAccess, session ); @@ -201,7 +193,7 @@ protected void logWarning(String description, String message) { private static void logStatement(String sql, JdbcServices jdbcServices) { - final SqlStatementLogger statementLogger = jdbcServices.getSqlStatementLogger(); - statementLogger.logStatement( sql, FormatStyle.BASIC.getFormatter() ); + jdbcServices.getSqlStatementLogger() + .logStatement( sql, FormatStyle.BASIC.getFormatter() ); } } diff --git a/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java b/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java index d6d8bab0a7b3..c4d0d0d9c7b8 100644 --- a/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java +++ b/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java @@ -122,7 +122,10 @@ void missingArguments( void propertiesNotFound(); @LogMessage(level = WARN) - @Message(value = "Recognized obsolete hibernate namespace %s. Use namespace %s instead. Refer to Hibernate 3.6 Migration Guide", + @Message( + value = """ + Recognized obsolete hibernate namespace %s.\ + Use namespace %s instead. Refer to Hibernate 3.6 Migration Guide""", id = 223) void recognizedObsoleteHibernateNamespace(String oldHibernateNamespace, String hibernateNamespace); @@ -245,7 +248,10 @@ void missingArguments( void unableToRunSchemaUpdate(@Cause Exception e); @LogMessage(level = WARN) - @Message(value = "The %s.%s.%s version of H2 implements temporary table creation such that it commits current transaction; multi-table, bulk HQL/JPQL will not work properly", + @Message( + value = """ + The %s.%s.%s version of H2 implements temporary table creation such that it commits current transaction;\ + multi-table, bulk HQL/JPQL will not work properly""", id = 393) void unsupportedMultiTableBulkHqlJpaql(int majorVersion, int minorVersion, int buildId); @@ -267,17 +273,19 @@ void missingArguments( @LogMessage(level = WARN) @Message( - value = "Dialect [%s] limits the number of elements in an IN predicate to %s entries. " + - "However, the given parameter list [%s] contained %s entries, which will likely cause failures " + - "to execute the query in the database", + value = """ + Dialect [%s] limits the number of elements in an IN predicate to %s entries. \ + However, the given parameter list [%s] contained %s entries, which will likely cause failures \ + to execute the query in the database""", id = 443 ) void tooManyInExpressions(String dialectName, int limit, String paramName, int size); @LogMessage(level = WARN) @Message( - value = "Encountered request for locking however dialect reports that database prefers locking be done in a " + - "separate select (follow-on locking); results will be locked after initial query executes", + value = """ + Encountered request for locking however dialect reports that database prefers locking be done in a \ + separate select (follow-on locking); results will be locked after initial query executes""", id = 444 ) void usingFollowOnLocking(); @@ -299,7 +307,11 @@ void missingArguments( void unsuccessfulSchemaManagementCommand(String command); @LogMessage(level = WARN) - @Message(value = "A ManagedEntity was associated with a stale PersistenceContext. A ManagedEntity may only be associated with one PersistenceContext at a time; %s", id = 480) + @Message( + value = """ + A ManagedEntity was associated with a stale PersistenceContext.\ + A ManagedEntity may only be associated with one PersistenceContext at a time; %s""", + id = 480) void stalePersistenceContextInEntityEntry(String msg); @LogMessage(level = ERROR) @@ -333,7 +345,10 @@ void missingArguments( void ignoreImmutablePropertyModification(String propertyName, String entityName); @LogMessage(level = WARN) - @Message(value = "Multiple configuration properties defined to create schema. Choose at most one among 'jakarta.persistence.create-database-schemas' or 'hibernate.hbm2ddl.create_namespaces'.", id = 504) + @Message(value = """ + Multiple configuration properties defined to create schema.\ + Choose at most one among 'jakarta.persistence.create-database-schemas' or 'hibernate.hbm2ddl.create_namespaces'.""", + id = 504) void multipleSchemaCreationSettingsDefined(); @LogMessage(level = WARN) @@ -345,7 +360,11 @@ void missingArguments( void fetchModeJoinWithLazyWarning(String role); @LogMessage(level = WARN) - @Message(value = "The %2$s version for [%s] is no longer supported, hence certain features may not work properly. The minimum supported version is %3$s. Check the community dialects project for available legacy versions.", id = 511) + @Message( + value = """ + The %2$s version for [%s] is no longer supported, hence certain features may not work properly.\ + The minimum supported version is %3$s. Check the community dialects project for available legacy versions.""", + id = 511) void unsupportedDatabaseVersion(String databaseName, String actualVersion, String minimumVersion); @LogMessage(level = DEBUG) @@ -386,4 +405,20 @@ void illegalArgumentOnStaticMetamodelFieldInjection( void unableToLocateStaticMetamodelField( String name, String name2); + + @LogMessage(level = DEBUG) + @Message( id = 6001, value = "Error creating temp table" ) + void errorCreatingTempTable(@Cause Exception e); + + @LogMessage(level = DEBUG) + @Message( id = 6002, value = "Unable to create temporary table [%s]: '%s' failed" ) + void unableToCreateTempTable(String qualifiedTableName, String creationCommand, @Cause SQLException e); + + @LogMessage(level = DEBUG) + @Message( id = 6003, value = "Error dropping temp table" ) + void errorDroppingTempTable(@Cause Exception e); + + @LogMessage(level = DEBUG) + @Message( id = 6004, value = "Unable to drop temporary table [%s]: '%s' failed" ) + void unableToDropTempTable(String qualifiedTableName, String creationCommand, @Cause SQLException e); } From a6df0788b1af439ec6d3a6e6105eb562e2164bca Mon Sep 17 00:00:00 2001 From: Gavin King Date: Sun, 14 Sep 2025 20:31:22 +0200 Subject: [PATCH 3/3] typesafe logging in cascade processing --- .../internal/ConfigurationServiceImpl.java | 9 +- .../hibernate/engine/internal/Cascade.java | 86 +++++++++---------- .../engine/spi/CascadingActions.java | 9 -- .../hibernate/engine/spi/CollectionEntry.java | 6 +- .../hibernate/internal/CoreMessageLogger.java | 48 +++++++++++ 5 files changed, 96 insertions(+), 62 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/engine/config/internal/ConfigurationServiceImpl.java b/hibernate-core/src/main/java/org/hibernate/engine/config/internal/ConfigurationServiceImpl.java index 2314913acbbf..005ee176c523 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/config/internal/ConfigurationServiceImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/config/internal/ConfigurationServiceImpl.java @@ -86,7 +86,8 @@ public void injectServices(ServiceRegistryImplementor serviceRegistry) { .classForName( candidate.toString() ); } catch ( ClassLoadingException e ) { - CORE_LOGGER.debugf( "Unable to locate %s implementation class %s", expected.getName(), candidate.toString() ); + CORE_LOGGER.debugf( "Unable to locate %s implementation class %s", + expected.getName(), candidate.toString() ); target = null; } } @@ -95,10 +96,8 @@ public void injectServices(ServiceRegistryImplementor serviceRegistry) { return target.newInstance(); } catch ( Exception e ) { - CORE_LOGGER.debugf( - "Unable to instantiate %s class %s", expected.getName(), - target.getName() - ); + CORE_LOGGER.debugf( "Unable to instantiate %s class %s", + expected.getName(), target.getName() ); } } return null; diff --git a/hibernate-core/src/main/java/org/hibernate/engine/internal/Cascade.java b/hibernate-core/src/main/java/org/hibernate/engine/internal/Cascade.java index d82412817098..d490df522cc4 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/internal/Cascade.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/internal/Cascade.java @@ -6,7 +6,6 @@ import java.util.ArrayList; import java.util.Collection; -import java.util.Iterator; import java.util.List; import org.hibernate.HibernateException; @@ -14,9 +13,7 @@ import org.hibernate.collection.spi.PersistentCollection; import org.hibernate.engine.spi.CascadeStyle; import org.hibernate.engine.spi.CascadingAction; -import org.hibernate.engine.spi.CollectionEntry; import org.hibernate.engine.spi.EntityEntry; -import org.hibernate.engine.spi.PersistenceContext; import org.hibernate.engine.spi.Status; import org.hibernate.event.spi.DeleteContext; import org.hibernate.event.spi.EventSource; @@ -82,7 +79,7 @@ public static void cascade( if ( action.anythingToCascade( persister ) ) { // performance opt final boolean traceEnabled = CORE_LOGGER.isTraceEnabled(); if ( traceEnabled ) { - CORE_LOGGER.tracev( "Processing cascade {0} for: {1}", action, persister.getEntityName() ); + CORE_LOGGER.processingCascade( action, persister.getEntityName() ); } final var bytecodeEnhancement = persister.getBytecodeEnhancementMetadata(); final EntityEntry entry; @@ -100,11 +97,11 @@ public static void cascade( final Type[] types = persister.getPropertyTypes(); final String[] propertyNames = persister.getPropertyNames(); - final CascadeStyle[] cascadeStyles = persister.getPropertyCascadeStyles(); + final var cascadeStyles = persister.getPropertyCascadeStyles(); final boolean hasUninitializedLazyProperties = bytecodeEnhancement.hasUnFetchedAttributes( parent ); for ( int i = 0; i < types.length; i++) { - final CascadeStyle style = cascadeStyles[ i ]; + final var style = cascadeStyles[ i ]; final String propertyName = propertyNames[ i ]; final Type type = types[i]; final boolean isUninitializedProperty = @@ -192,7 +189,7 @@ && isLogicalOneToOne( type ) ) { } if ( traceEnabled ) { - CORE_LOGGER.tracev( "Done processing cascade {0} for: {1}", action, persister.getEntityName() ); + CORE_LOGGER.doneProcessingCascade( action, persister.getEntityName() ); } } } @@ -288,8 +285,8 @@ private static void cascadeLogicalOneToOneOrphanRemoval( if ( style.hasOrphanDelete() && action.deleteOrphans() ) { // value is orphaned if loaded state for this property shows not null // because it is currently null. - final PersistenceContext persistenceContext = eventSource.getPersistenceContextInternal(); - final EntityEntry entry = persistenceContext.getEntry( parent ); + final var persistenceContext = eventSource.getPersistenceContextInternal(); + final var entry = persistenceContext.getEntry( parent ); if ( entry != null && entry.getStatus() != Status.SAVING ) { Object loadedValue; if ( componentPath == null ) { @@ -324,13 +321,11 @@ private static void cascadeLogicalOneToOneOrphanRemoval( // entity is managed (without first nulling and manually flushing). if ( child == null || loadedValue != null && child != loadedValue ) { EntityEntry valueEntry = persistenceContext.getEntry( loadedValue ); - if ( valueEntry == null && isHibernateProxy( loadedValue ) ) { // un-proxy and re-associate for cascade operation // useful for @OneToOne defined as FetchType.LAZY loadedValue = persistenceContext.unproxyAndReassociate( loadedValue ); valueEntry = persistenceContext.getEntry( loadedValue ); - // HHH-11965 // Should the unwrapped proxy value be equal via reference to the entity's property value // provided by the 'child' variable, we should not trigger the orphan removal of the @@ -342,15 +337,12 @@ private static void cascadeLogicalOneToOneOrphanRemoval( } if ( valueEntry != null ) { - final EntityPersister persister = valueEntry.getPersister(); + final var persister = valueEntry.getPersister(); final String entityName = persister.getEntityName(); if ( CORE_LOGGER.isTraceEnabled() ) { - CORE_LOGGER.tracev( - "Deleting orphaned entity instance: {0}", - infoString( entityName, persister.getIdentifier( loadedValue, eventSource ) ) - ); + CORE_LOGGER.deletingOrphan( + infoString( entityName, persister.getIdentifier( loadedValue, eventSource ) ) ); } - if ( isForeignKeyToParent( type ) ) { // If FK direction is to-parent, we must remove the orphan *before* the queued update(s) // occur. Otherwise, replacing the association on a managed entity, without manually @@ -487,10 +479,10 @@ private static void cascadeCollection( final CascadeStyle style, final T anything, final CollectionType type) { - final CollectionPersister persister = + final var persister = eventSource.getFactory().getMappingMetamodel() .getCollectionDescriptor( type.getRole() ); - final Type elemType = persister.getElementType(); + final var elemType = persister.getElementType(); //cascade to current collection elements if ( elemType instanceof EntityType || elemType instanceof AnyType || elemType instanceof ComponentType ) { cascadeCollectionElements( @@ -530,15 +522,18 @@ private static void cascadeToOne( final List componentPath) { if ( style.reallyDoCascade( action ) ) { //not really necessary, but good for consistency... - final PersistenceContext persistenceContext = eventSource.getPersistenceContextInternal(); + final var persistenceContext = eventSource.getPersistenceContextInternal(); persistenceContext.addChildParent( child, parent ); + final String childEntityName = + type instanceof EntityType entityType + ? entityType.getAssociatedEntityName() + : null; + CORE_LOGGER.cascading( action, childEntityName ); try { action.cascade( eventSource, child, - type instanceof EntityType entityType - ? entityType.getAssociatedEntityName() - : null, + childEntityName, parentEntityName, propertyName, componentPath, @@ -572,14 +567,12 @@ private static void cascadeCollectionElements( final boolean reallyDoCascade = style.reallyDoCascade( action ) && child != CollectionType.UNFETCHED_COLLECTION; - if ( reallyDoCascade ) { final boolean traceEnabled = CORE_LOGGER.isTraceEnabled(); if ( traceEnabled ) { - CORE_LOGGER.tracev( "Cascade {0} for collection: {1}", action, collectionType.getRole() ); + CORE_LOGGER.cascadingCollection( action, collectionType.getRole() ); } - - final Iterator iterator = action.getCascadableChildrenIterator( eventSource, collectionType, child ); + final var iterator = action.getCascadableChildrenIterator( eventSource, collectionType, child ); while ( iterator.hasNext() ) { cascadeProperty( action, @@ -597,14 +590,13 @@ private static void cascadeCollectionElements( isCascadeDeleteEnabled ); } - if ( traceEnabled ) { - CORE_LOGGER.tracev( "Done cascade {0} for collection: {1}", action, collectionType.getRole() ); + CORE_LOGGER.doneCascadingCollection( action, collectionType.getRole() ); } } // a newly instantiated collection can't have orphans - final PersistentCollection persistentCollection = + final var persistentCollection = child instanceof PersistentCollection collection ? collection : eventSource.getPersistenceContextInternal() @@ -620,16 +612,15 @@ private static void cascadeCollectionElements( if ( deleteOrphans ) { final boolean traceEnabled = CORE_LOGGER.isTraceEnabled(); if ( traceEnabled ) { - CORE_LOGGER.tracev( "Deleting orphans for collection: {0}", collectionType.getRole() ); + CORE_LOGGER.deletingOrphans( collectionType.getRole() ); } // we can do the cast since orphan-delete does not apply to: // 1. newly instantiated collections // 2. arrays (we can't track orphans for detached arrays) final String elementEntityName = collectionType.getAssociatedEntityName( eventSource.getFactory() ); deleteOrphans( eventSource, elementEntityName, persistentCollection ); - if ( traceEnabled ) { - CORE_LOGGER.tracev( "Done deleting orphans for collection: {0}", collectionType.getRole() ); + CORE_LOGGER.doneDeletingOrphans( collectionType.getRole() ); } } } @@ -637,25 +628,30 @@ private static void cascadeCollectionElements( /** * Delete any entities that were removed from the collection */ - private static void deleteOrphans(EventSource eventSource, String entityName, PersistentCollection pc) { + private static void deleteOrphans(EventSource eventSource, String entityName, PersistentCollection collection) { //TODO: suck this logic into the collection! - final Collection orphans; - if ( pc.wasInitialized() ) { - final CollectionEntry entry = eventSource.getPersistenceContextInternal().getCollectionEntry( pc ); - orphans = entry == null ? EMPTY_LIST : entry.getOrphans( entityName, pc ); - } - else { - orphans = pc.getQueuedOrphans( entityName ); - } - - for ( Object orphan : orphans ) { + for ( Object orphan : getOrphans( eventSource, entityName, collection ) ) { if ( orphan != null ) { - CORE_LOGGER.tracev( "Deleting orphaned entity instance: {0}", entityName ); + CORE_LOGGER.deletingOrphanOfType( entityName ); eventSource.delete( entityName, orphan, false, DeleteContext.create() ); } } } + private static Collection getOrphans(EventSource eventSource, String entityName, PersistentCollection collection) { + if ( collection.wasInitialized() ) { + final var collectionEntry = + eventSource.getPersistenceContextInternal() + .getCollectionEntry( collection ); + return collectionEntry == null + ? EMPTY_LIST + : collectionEntry.getOrphans( entityName, collection ); + } + else { + return collection.getQueuedOrphans( entityName ); + } + } + private static boolean cascadeDeleteEnabled(CascadingAction action, CollectionPersister persister) { return action.directionAffectedByCascadeDelete() == ForeignKeyDirection.FROM_PARENT && persister.isCascadeDeleteEnabled(); diff --git a/hibernate-core/src/main/java/org/hibernate/engine/spi/CascadingActions.java b/hibernate-core/src/main/java/org/hibernate/engine/spi/CascadingActions.java index f51f085740f1..12dc3f67a97a 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/spi/CascadingActions.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/spi/CascadingActions.java @@ -32,7 +32,6 @@ import static java.util.Collections.emptyIterator; import static org.hibernate.engine.internal.ForeignKeys.isTransient; import static org.hibernate.engine.internal.ManagedTypeHelper.isHibernateProxy; -import static org.hibernate.internal.CoreMessageLogger.CORE_LOGGER; import static org.hibernate.internal.util.StringHelper.join; /** @@ -60,7 +59,6 @@ public void cascade( List attributePath, DeleteContext context, boolean isCascadeDeleteEnabled) { - CORE_LOGGER.tracev( "Cascading to delete: {0}", childEntityName ); session.delete( childEntityName, child, isCascadeDeleteEnabled, context ); } @@ -121,7 +119,6 @@ public void cascade( List attributePath, LockOptions lockOptions, boolean isCascadeDeleteEnabled) { - CORE_LOGGER.tracev( "Cascading to lock: {0}", childEntityName ); session.lock( childEntityName, child, lockOptions ); } @@ -161,7 +158,6 @@ public void cascade( RefreshContext context, boolean isCascadeDeleteEnabled) throws HibernateException { - CORE_LOGGER.tracev( "Cascading to refresh: {0}", childEntityName ); session.refresh( childEntityName, child, context ); } @@ -200,7 +196,6 @@ public void cascade( Void nothing, boolean isCascadeDeleteEnabled) throws HibernateException { - CORE_LOGGER.tracev( "Cascading to evict: {0}", childEntityName ); session.evict( child ); } @@ -244,7 +239,6 @@ public void cascade( MergeContext context, boolean isCascadeDeleteEnabled) throws HibernateException { - CORE_LOGGER.tracev( "Cascading to merge: {0}", childEntityName ); session.merge( childEntityName, child, context ); } @@ -284,7 +278,6 @@ public void cascade( PersistContext context, boolean isCascadeDeleteEnabled) throws HibernateException { - CORE_LOGGER.tracev( "Cascading to persist: {0}", childEntityName ); session.persist( childEntityName, child, context ); } @@ -335,7 +328,6 @@ public void cascade( PersistContext context, boolean isCascadeDeleteEnabled) throws HibernateException { - CORE_LOGGER.tracev( "Cascading to persist on flush: {0}", childEntityName ); session.persistOnFlush( childEntityName, child, context ); } @@ -540,7 +532,6 @@ public void cascade( ReplicationMode mode, boolean isCascadeDeleteEnabled) throws HibernateException { - CORE_LOGGER.tracev( "Cascading to replicate: {0}", childEntityName ); session.replicate( childEntityName, child, mode ); } diff --git a/hibernate-core/src/main/java/org/hibernate/engine/spi/CollectionEntry.java b/hibernate-core/src/main/java/org/hibernate/engine/spi/CollectionEntry.java index a9f0920baab8..f6981b79b4f3 100644 --- a/hibernate-core/src/main/java/org/hibernate/engine/spi/CollectionEntry.java +++ b/hibernate-core/src/main/java/org/hibernate/engine/spi/CollectionEntry.java @@ -184,8 +184,8 @@ public void preFlush(PersistentCollection collection) { dirty( collection ); if ( CORE_LOGGER.isTraceEnabled() && collection.isDirty() && loadedPersister != null ) { - CORE_LOGGER.trace( "Collection dirty: " - + collectionInfoString( loadedPersister.getRole(), getLoadedKey() ) ); + CORE_LOGGER.collectionDirty( + collectionInfoString( loadedPersister.getRole(), getLoadedKey() ) ); } setReached( false ); @@ -265,7 +265,7 @@ public void afterAction(PersistentCollection collection) { * @param storedSnapshot the new stored snapshot */ public void resetStoredSnapshot(PersistentCollection collection, Serializable storedSnapshot) { - CORE_LOGGER.tracef("Reset storedSnapshot to %s for %s", storedSnapshot, this); + CORE_LOGGER.resetStoredSnapshot( storedSnapshot, this ); if ( !fromMerge ) { snapshot = storedSnapshot; diff --git a/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java b/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java index c4d0d0d9c7b8..abdef1e79889 100644 --- a/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java +++ b/hibernate-core/src/main/java/org/hibernate/internal/CoreMessageLogger.java @@ -5,6 +5,7 @@ package org.hibernate.internal; import java.io.IOException; +import java.io.Serializable; import java.lang.invoke.MethodHandles; import java.sql.SQLException; import java.sql.SQLWarning; @@ -13,6 +14,8 @@ import org.hibernate.HibernateException; import org.hibernate.Internal; import org.hibernate.cache.CacheException; +import org.hibernate.engine.spi.CascadingAction; +import org.hibernate.engine.spi.CollectionEntry; import org.hibernate.internal.log.SubSystemLogging; import org.jboss.logging.BasicLogger; @@ -28,6 +31,7 @@ import static org.jboss.logging.Logger.Level.DEBUG; import static org.jboss.logging.Logger.Level.ERROR; import static org.jboss.logging.Logger.Level.INFO; +import static org.jboss.logging.Logger.Level.TRACE; import static org.jboss.logging.Logger.Level.WARN; /** @@ -421,4 +425,48 @@ void unableToLocateStaticMetamodelField( @LogMessage(level = DEBUG) @Message( id = 6004, value = "Unable to drop temporary table [%s]: '%s' failed" ) void unableToDropTempTable(String qualifiedTableName, String creationCommand, @Cause SQLException e); + + @LogMessage(level = TRACE) + @Message( id = 6005, value = "Cascading %s to child entity '%s'" ) + void cascading(CascadingAction delete, String childEntityName); + + @LogMessage(level = TRACE) + @Message( id = 6006, value = "Cascading %s to collection '%s'" ) + void cascadingCollection(CascadingAction delete, String collectionRole); + + @LogMessage(level = TRACE) + @Message( id = 6007, value = "Done cascading %s to collection '%s'" ) + void doneCascadingCollection(CascadingAction delete, String collectionRole); + + @LogMessage(level = TRACE) + @Message( id = 6008, value = "Processing cascade %s for entity '%s'" ) + void processingCascade(CascadingAction action, String entityName); + + @LogMessage(level = TRACE) + @Message( id = 6009, value = "Processing cascade %s for entity '%s'" ) + void doneProcessingCascade(CascadingAction action, String entityName); + + @LogMessage(level = TRACE) + @Message( id = 6011, value = "Deleting orphaned child entity instance of type '%s'" ) + void deletingOrphanOfType(String entityName); + + @LogMessage(level = TRACE) + @Message( id = 6012, value = "Deleting orphaned child entity instance: %s" ) + void deletingOrphan(String info); + + @LogMessage(level = TRACE) + @Message( id = 6013, value = "Deleting orphans for collection '%s'" ) + void deletingOrphans(String role); + + @LogMessage(level = TRACE) + @Message( id = 6014, value = "Done deleting orphans for collection '%s'" ) + void doneDeletingOrphans(String role); + + @LogMessage(level = TRACE) + @Message( id = 6021, value = "Collection dirty: %s" ) + void collectionDirty(String info); + + @LogMessage(level = TRACE) + @Message( id = 6022, value = "Reset storedSnapshot to %s for %s" ) + void resetStoredSnapshot(Serializable storedSnapshot, CollectionEntry collectionEntry); }