## org.hibernate.internal
Interface CoreMessageLogger

All Superinterfaces:
  org.jboss.logging.BasicLogger

All Known Subinterfaces:
  C3P0MessageLogger, EhCacheMessageLogger, EntityManagerMessageLogger, EnversMessageLogger, ProxoolMessageLogger

All Known Implementing Classes:
  C3P0MessageLogger_$logger, CoreMessageLogger_$logger, EhCacheMessageLogger_$logger, EntityManagerMessageLogger_$logger, EnversMessageLogger_$logger, ProxoolMessageLogger_$logger

    @MessageLogger(projectCode="HHH")
    public interface CoreMessageLogger

extends org.jboss.logging.BasicLogger

The jboss-logging `MessageLogger` for the hibernate-core module. It reserves message ids ranging from 00001 to 10000 inclusively.

New messages must be added after the last message defined to ensure message codes are unique.

Method Summary
`void` `addingOverrideFor(String name, String name2)`
`void` `alreadySessionBound()`
`void` `autoCommitMode(boolean autocommit)`
`void` `autoFlushWillNotWork()`
`void` `batchContainedStatementsOnRelease()`
`void` `bytecodeProvider(String provider)`
`void` `c3p0ProviderClassNotFound(String c3p0ProviderClassName)`
`void` `cachedFileNotFound(String path, FileNotFoundException error)`
`void` `cacheProvider(String name)`
`void` `callingJoinTransactionOnNonJtaEntityManager()`
`void` `cannotResolveNonNullableTransientDependencies(String transientEntityString, Set<String> dependentEntityStrings, Set<String> nonNullableAssociationPaths)`
`void` `cleaningUpConnectionPool(String url)`
`void` `closing()`
`void` `closingUnreleasedBatch()`
`void` `collectionsFetched(long collectionFetchCount)`
`void` `collectionsLoaded(long collectionLoadCount)`
`void` `collectionsRecreated(long collectionRecreateCount)`
`void` `collectionsRemoved(long collectionRemoveCount)`
`void` `collectionsUpdated(long collectionUpdateCount)`
`void` `columns(Set keySet)`
`void` `compositeIdClassDoesNotOverrideEquals(String name)`
`void` `compositeIdClassDoesNotOverrideHashCode(String name)`
`void` `configurationResource(String resource)`
`void` `configuredSessionFactory(String name)`
`void` `configuringFromFile(String file)`
`void` `configuringFromResource(String resource)`
`void` `configuringFromUrl(URL url)`
`void` `configuringFromXmlDocument()`
`void` `connectionProperties(Properties connectionProps)`
`void` `connectionsObtained(long connectCount)`
`void` `containerProvidingNullPersistenceUnitRootUrl()`
`void` `containsJoinFetchedCollection(String role)`
`void` `couldNotBindJndiListener()`
`void` `creatingSubcontextInfo(String intermediateContextName)`
`void` `definingFlushBeforeCompletionIgnoredInHem(String flushBeforeCompletion)`
`void` `deprecatedDerbyDialect()`
`void` `deprecatedForceDescriminatorAnnotation()`
`void` `deprecatedOracle9Dialect()`
`void` `deprecatedOracleDialect()`
`void` `deprecatedTransactionManagerStrategy(String name, String transactionManagerStrategy, String name2, String jtaPlatform)`
`void` `deprecatedUuidGenerator(String name, String name2)`
`void` `disablingContextualLOBCreation(String nonContextualLobCreation)`
`void` `disablingContextualLOBCreationSinceConnectionNull()`
`void` `disablingContextualLOBCreationSinceCreateClobFailed(Throwable t)`
`void` `disablingContextualLOBCreationSinceOldJdbcVersion(int jdbcMajorVersion)`
`void` `disallowingInsertStatementComment()`
`void` `duplicateGeneratorName(String name)`
`void` `duplicateGeneratorTable(String name)`
`void` `duplicateImport(String entityName, String rename)`
`void` `duplicateJoins(String entityName)`
`void` `duplicateListener(String className)`
`void` `duplicateMetadata()`
`void` `entitiesDeleted(long entityDeleteCount)`
`void` `entitiesFetched(long entityFetchCount)`
`void` `entitiesInserted(long entityInsertCount)`
`void` `entitiesLoaded(long entityLoadCount)`
`void` `entitiesUpdated(long entityUpdateCount)`
`void` `entityAnnotationOnNonRoot(String className)`
`void` `entityIdentifierValueBindingExists(String name)`
`void` `entityManagerClosedBySomeoneElse(String autoCloseSession)`
`void` `entityManagerFactoryAlreadyRegistered(String emfName, String propertyName)`
`void` `entityMappedAsNonAbstract(String name)`
`void` `exceptionHeaderFound(String exceptionHeader, String metaInfOrmXml)`
`void` `exceptionHeaderNotFound(String exceptionHeader, String metaInfOrmXml)`
`void` `exceptionInAfterTransactionCompletionInterceptor(Throwable e)`
`void` `exceptionInBeforeTransactionCompletionInterceptor(Throwable e)`
`void` `exceptionInSubResolver(String message)`
`void` `expectedType(String name, String string)`
`void` `expired(Object key)`
`void` `factoryBoundToJndiName(String name)`
`void` `factoryJndiRename(String oldName, String newName)`
`void` `factoryUnboundFromJndiName(String name)`
`void` `factoryUnboundFromName(String name)`
`void` `failed(Throwable throwable)`
`void` `failSafeCollectionsCleanup(CollectionLoadContext collectionLoadContext)`
`void` `failSafeEntitiesCleanup(EntityLoadContext entityLoadContext)`
`void` `fetchingDatabaseMetadata()`
`void` `filterAnnotationOnSubclass(String className)`
`void` `firstOrMaxResultsSpecifiedWithCollectionFetch()`
`void` `flushes(long flushCount)`
`void` `forcingContainerResourceCleanup()`
`void` `forcingTableUse()`
`void` `foreignKeys(Set keySet)`
`void` `foundMappingDocument(String name)`
`void` `gettersOfLazyClassesCannotBeFinal(String entityName, String name)`
`void` `guidGenerated(String result)`
`void` `handlingTransientEntity()`
`void` `hibernateConnectionPoolSize(int poolSize)`
`void` `honoringOptimizerSetting(String none, String incrementParam, int incrementSize)`
`void` `hql(String hql, Long valueOf, Long valueOf2)`
`void` `hsqldbSupportsOnlyReadCommittedIsolation()`
`void` `hydratingEntitiesCount(int size)`
`void` `ignoringTableGeneratorConstraints(String name)`
`void` `ignoringUnrecognizedQueryHint(String hintName)`
`void` `illegalPropertyGetterArgument(String name, String propertyName)`
`void` `illegalPropertySetterArgument(String name, String propertyName)`
`void` `immutableAnnotationOnNonRoot(String className)`
`void` `incompleteMappingMetadataCacheProcessing()`
`void` `indexes(Set keySet)`
`void` `instantiatingExplicitConnectionProvider(String providerClassName)`
`void` `invalidArrayElementType(String message)`
`void` `invalidDiscriminatorAnnotation(String className)`
`void` `invalidEditOfReadOnlyItem(Object key)`
`void` `invalidJndiName(String name, JndiNameException e)`
`void` `invalidOnDeleteAnnotation(String entityName)`
`void` `invalidPrimaryKeyJoinColumnAnnotation()`
`void` `invalidSubStrategy(String className)`
`void` `invalidTableAnnotation(String className)`
`void` `jaccContextId(String contextId)`
`void` `JavaSqlTypesMappedSameCodeMultipleTimes(int code, String old, String name)`
`String` `javassistEnhancementFailed(String entityName)`
`void` `jdbcAutoCommitFalseBreaksEjb3Spec(String autocommit)`
`void` `jdbcDriverNotSpecified(String driver)`
`void` `jdbcIsolationLevel(String isolationLevelToString)`
`String` `jdbcRollbackFailed()`
`String` `jdbcUrlNotSpecified(String url)`
`void` `jndiInitialContextProperties(Hashtable hash)`
`void` `jndiNameDoesNotHandleSessionFactoryReference(String sfJNDIName, ClassCastException e)`
`void` `lazyPropertyFetchingAvailable(String name)`
`void` `legacyTransactionManagerStrategy(String name, String jtaPlatform)`
`void` `loadingCollectionKeyNotFound(CollectionKey collectionKey)`
`void` `localLoadingCollectionKeysCount(int size)`
`void` `loggingStatistics()`
`void` `logicalConnectionClosed()`
`void` `logicalConnectionReleasingPhysicalConnection()`
`void` `maxQueryTime(long queryExecutionMaxTime)`
`void` `missingArguments(int anticipatedNumberOfArguments, int numberOfArguments)`
`void` `missingEntityAnnotation(String className)`
`void` `namedQueryError(String queryName, HibernateException e)`
`void` `namingExceptionAccessingFactory(NamingException exception)`
`void` `narrowingProxy(Class concreteProxyClass)`
`void` `naturalIdCacheHits(long naturalIdCacheHitCount)`
`void` `naturalIdCacheMisses(long naturalIdCacheMissCount)`
`void` `naturalIdCachePuts(long naturalIdCachePutCount)`
`void` `naturalIdMaxQueryTime(long naturalIdQueryExecutionMaxTime)`
`void` `naturalIdQueriesExecuted(long naturalIdQueriesExecutionCount)`
`void` `needsLimit()`
`void` `noAppropriateConnectionProvider()`
`void` `noColumnsSpecifiedForIndex(String indexName, String tableName)`
`void` `noDefaultConstructor(String name)`
`void` `noPersistentClassesFound(String query)`
`void` `noSessionFactoryWithJndiName(String sfJNDIName, NameNotFoundException e)`
`void` `optimisticLockFailures(long optimisticFailureCount)`
`void` `orderByAnnotationIndexedCollection()`
`void` `overridingTransactionStrategyDangerous(String transactionStrategy)`
`void` `packageNotFound(String packageName)`
`void` `parameterPositionOccurredAsBothJpaAndHibernatePositionalParameter(Integer position)`
`void` `parsingXmlError(int lineNumber, String message)`
`void` `parsingXmlErrorForFile(String file, int lineNumber, String message)`
`void` `parsingXmlWarning(int lineNumber, String message)`
`void` `parsingXmlWarningForFile(String file, int lineNumber, String message)`
`void` `persistenceProviderCallerDoesNotImplementEjb3SpecCorrectly()`
`void` `pooledOptimizerReportedInitialValue(IntegralDataTypeHolder value)`
`void` `preparedStatementAlreadyInBatch(String sql)`
`void` `processEqualityExpression()`
`void` `processingPersistenceUnitInfoName(String persistenceUnitName)`
`void` `propertiesLoaded(Properties maskOut)`
`void` `propertiesNotFound()`
`void` `propertyNotFound(String property)`
`void` `providerClassDeprecated(String providerClassName, String actualProviderClassName)`
`void` `proxoolProviderClassNotFound(String proxoolProviderClassName)`
`void` `queriesExecuted(long queryExecutionCount)`
`void` `queryCacheHits(long queryCacheHitCount)`
`void` `queryCacheMisses(long queryCacheMissCount)`
`void` `queryCachePuts(long queryCachePutCount)`
`void` `rdmsOs2200Dialect()`
`void` `readingCachedMappings(File cachedFile)`
`void` `readingMappingsFromFile(String path)`
`void` `readingMappingsFromResource(String resourceName)`
`void` `readOnlyCacheConfiguredForMutableCollection(String name)`
`void` `recognizedObsoleteHibernateNamespace(String oldHibernateNamespace, String hibernateNamespace)`
`void` `renamedProperty(Object propertyName, Object newPropertyName)`
`void` `requiredDifferentProvider(String provider)`
`void` `resolvedSqlTypeDescriptorForDifferentSqlCode(String name, String valueOf, String name2, String valueOf2)`
`void` `runningHbm2ddlSchemaExport()`
`void` `runningHbm2ddlSchemaUpdate()`
`void` `runningSchemaValidator()`
`void` `schemaExportComplete()`
`void` `schemaExportUnsuccessful(Exception e)`
`void` `schemaUpdateComplete()`
`void` `scopingTypesToSessionFactoryAfterAlreadyScoped(SessionFactoryImplementor factory, SessionFactoryImplementor factory2)`
`void` `searchingForMappingDocuments(String name)`
`void` `secondLevelCacheHits(long secondLevelCacheHitCount)`
`void` `secondLevelCacheMisses(long secondLevelCacheMissCount)`
`void` `secondLevelCachePuts(long secondLevelCachePutCount)`
`void` `serviceProperties(Properties properties)`
`void` `sessionsClosed(long sessionCloseCount)`
`void` `sessionsOpened(long sessionOpenCount)`
`void` `setManagerLookupClass()`
`void` `settersOfLazyClassesCannotBeFinal(String entityName, String name)`
`void` `sortAnnotationIndexedCollection()`
`void` `splitQueries(String sourceQuery, int length)`
`void` `sqlExceptionEscapedProxy(SQLException e)`
`void` `sqlWarning(int errorCode, String sqlState)`
`void` `startingQueryCache(String region)`
`void` `startingServiceAtJndiName(String boundName)`
`void` `startingUpdateTimestampsCache(String region)`
`void` `startTime(long startTime)`
`void` `statementsClosed(long closeStatementCount)`
`void` `statementsPrepared(long prepareStatementCount)`
`void` `stoppingService()`
`void` `subResolverException(String message)`
`void` `successfulTransactions(long committedTransactionCount)`
`void` `synchronizationAlreadyRegistered(Synchronization synchronization)`
`void` `synchronizationFailed(Synchronization synchronization, Throwable t)`
`void` `tableFound(String string)`
`void` `tableNotFound(String name)`
`void` `timestampCacheHits(long updateTimestampsCachePutCount)`
`void` `timestampCacheMisses(long updateTimestampsCachePutCount)`
`void` `timestampCachePuts(long updateTimestampsCachePutCount)`
`void` `transactions(long transactionCount)`
`void` `transactionStartedOnNonRootSession()`
`void` `transactionStrategy(String strategyClassName)`
`void` `typeDefinedNoRegistrationKeys(BasicType type)`
`void` `typeRegistrationOverridesPrevious(String key, Type old)`
`void` `unableToAccessEjb3Configuration(NamingException e)`
`void` `unableToAccessSessionFactory(String sfJNDIName, NamingException e)`
`void` `unableToAccessTypeInfoResultSet(String string)`
`void` `unableToApplyConstraints(String className, Exception e)`
`void` `unableToBindEjb3ConfigurationToJndi(JndiException e)`
`void` `unableToBindFactoryToJndi(JndiException e)`
`void` `unableToBindValueToParameter(String nullSafeToString, int index, String message)`
`void` `unableToBuildEnhancementMetamodel(String className)`
`void` `unableToBuildSessionFactoryUsingMBeanClasspath(String message)`
`void` `unableToCleanUpCallableStatement(SQLException e)`
`void` `unableToCleanUpPreparedStatement(SQLException e)`
`void` `unableToCleanupTemporaryIdTable(Throwable t)`
`void` `unableToCloseConnection(Exception e)`
`void` `unableToCloseInitialContext(String string)`
`void` `unableToCloseInputFiles(String name, IOException e)`
`void` `unableToCloseInputStream(IOException e)`
`void` `unableToCloseInputStreamForResource(String resourceName, IOException e)`
`void` `unableToCloseIterator(SQLException e)`
`void` `unableToCloseJar(String message)`
`void` `unableToCloseOutputFile(String outputFile, IOException e)`
`void` `unableToCloseOutputStream(IOException e)`
`void` `unableToClosePooledConnection(SQLException e)`
`void` `unableToCloseSession(HibernateException e)`
`void` `unableToCloseSessionButSwallowingError(HibernateException e)`
`void` `unableToCloseSessionDuringRollback(Exception e)`
`void` `unableToCloseStream(IOException e)`
`void` `unableToCloseStreamError(IOException error)`
`String` `unableToCommitJta()`
`void` `unableToCompleteSchemaUpdate(Exception e)`
`void` `unableToCompleteSchemaValidation(SQLException e)`
`void` `unableToConfigureSqlExceptionConverter(HibernateException e)`
`void` `unableToConstructCurrentSessionContext(String impl, Throwable e)`
`void` `unableToConstructSqlExceptionConverter(Throwable t)`
`void` `unableToCopySystemProperties()`
`void` `unableToCreateProxyFactory(String entityName, HibernateException e)`
`void` `unableToCreateSchema(Exception e)`
`void` `unableToDeserializeCache(String path, SerializationException error)`
`void` `unableToDestroyCache(String message)`
`void` `unableToDestroyQueryCache(String region, String message)`
`void` `unableToDestroyUpdateTimestampsCache(String region, String message)`
`void` `unableToDetermineLockModeValue(String hintName, Object value)`
`String` `unableToDetermineTransactionStatus()`
`String` `unableToDetermineTransactionStatusAfterCommit()`
`void` `unableToDropTemporaryIdTable(String message)`
`void` `unableToExecuteBatch(String message)`
`void` `unableToExecuteResolver(AbstractDialectResolver abstractDialectResolver, String message)`
`void` `unableToFindPersistenceXmlInClasspath()`
`void` `unableToGetDatabaseMetadata(SQLException e)`
`void` `unableToInstantiateConfiguredSchemaNameResolver(String resolverClassName, String message)`
`void` `unableToInstantiateOptimizer(String type)`
`void` `unableToInstantiateUuidGenerationStrategy(Exception ignore)`
`void` `unableToJoinTransaction(String transactionStrategy)`
`void` `unableToLoadCommand(HibernateException e)`
`void` `unableToLoadDerbyDriver(String message)`
`void` `unableToLoadProperties()`
`String` `unableToLocateConfigFile(String path)`
`void` `unableToLocateConfiguredSchemaNameResolver(String resolverClassName, String message)`
`void` `unableToLocateCustomOptimizerClass(String type)`
`void` `unableToLocateMBeanServer()`
`void` `unableToLocateUuidGenerationStrategy(String strategyClassName)`
`void` `unableToLogSqlWarnings(SQLException sqle)`
`void` `unableToLogWarnings(SQLException e)`
`void` `unableToMarkForRollbackOnPersistenceException(Exception e)`
`void` `unableToMarkForRollbackOnTransientObjectException(Exception e)`
`void` `unableToObjectConnectionMetadata(SQLException error)`
`void` `unableToObjectConnectionToQueryMetadata(SQLException error)`
`void` `unableToObtainConnectionMetadata(String message)`
`void` `unableToObtainConnectionToQueryMetadata(String message)`
`void` `unableToObtainInitialContext(NamingException e)`
`void` `unableToParseMetadata(String packageName)`
`String` `unableToPerformJdbcCommit()`
`void` `unableToPerformManagedFlush(String message)`
`String` `unableToQueryDatabaseMetadata()`
`void` `unableToReadClass(String message)`
`void` `unableToReadColumnValueFromResultSet(String name, String message)`
`String` `unableToReadHiValue(String tableName)`
`void` `unableToReadOrInitHiValue(SQLException e)`
`void` `unableToReleaseBatchStatement()`
`void` `unableToReleaseCacheLock(CacheException ce)`
`void` `unableToReleaseContext(String message)`
`void` `unableToReleaseCreatedMBeanServer(String string)`
`void` `unableToReleaseIsolatedConnection(Throwable ignore)`
`void` `unableToReleaseTypeInfoResultSet()`
`void` `unableToRemoveBagJoinFetch()`
`void` `unableToResolveAggregateFunction(String name)`
`void` `unableToResolveMappingFile(String xmlFile)`
`void` `unableToRetrieveCache(String namespace, String message)`
`void` `unableToRetrieveTypeInfoResultSet(String string)`
`void` `unableToRollbackConnection(Exception ignore)`
`void` `unableToRollbackIsolatedTransaction(Exception e, Exception ignore)`
`String` `unableToRollbackJta()`
`void` `unableToRunSchemaUpdate(Exception e)`
`void` `unableToSetTransactionToRollbackOnly(SystemException e)`
`void` `unableToStopHibernateService(Exception e)`
`void` `unableToStopService(Class class1, String string)`
`void` `unableToSwitchToMethodUsingColumnIndex(Method method)`
`void` `unableToSynchronizeDatabaseStateWithSession(HibernateException he)`
`void` `unableToToggleAutoCommit(Exception e)`
`void` `unableToTransformClass(String message)`
`void` `unableToUnbindFactoryFromJndi(JndiException e)`
`Object` `unableToUpdateHiValue(String tableName)`
`void` `unableToUpdateQueryHiValue(String tableName, SQLException e)`
`void` `unableToWrapResultSet(SQLException e)`
`void` `unableToWriteCachedFile(String path, String message)`
`void` `undeterminedH2Version()`
`void` `unexpectedLiteralTokenType(int type)`
`void` `unexpectedRowCounts()`
`void` `unknownBytecodeProvider(String providerName)`
`void` `unknownIngresVersion(int databaseMajorVersion)`
`void` `unknownOracleVersion(int databaseMajorVersion)`
`void` `unknownSqlServerVersion(int databaseMajorVersion)`
`void` `unregisteredResultSetWithoutStatement()`
`void` `unregisteredStatement()`
`void` `unsuccessful(String sql)`
`void` `unsuccessfulCreate(String string)`
`void` `unsupportedAfterStatement()`
`void` `unsupportedIngresVersion()`
`void` `unsupportedInitialValue(String propertyName)`
`void` `unsupportedMultiTableBulkHqlJpaql(int majorVersion, int minorVersion, int buildId)`
`void` `unsupportedOracleVersion()`
`void` `unsupportedProperty(Object propertyName, Object newPropertyName)`
`void` `updatingSchema()`
`void` `usingAstQueryTranslatorFactory()`
`void` `usingDefaultIdGeneratorSegmentValue(String tableName, String segmentColumnName, String defaultToUse)`
`void` `usingDefaultTransactionStrategy()`
`void` `usingDialect(Dialect dialect)`
`void` `usingDriver(String driverClassName, String url)`
`void` `usingHibernateBuiltInConnectionPool()`
`void` `usingOldDtd()`
`void` `usingReflectionOptimizer()`
`void` `usingStreams()`
`void` `usingTimestampWorkaround()`
`void` `usingUuidHexGenerator(String name, String name2)`
`void` `validatorNotFound()`
`void` `version(String versionString)`
`void` `warningsCreatingTempTable(SQLWarning warning)`
`void` `willNotRegisterListeners()`
`void` `writeLocksNotSupported(String entityName)`
`void` `writingGeneratedSchemaToFile(String outputFile)`

Methods inherited from interface org.jboss.logging.BasicLogger

`debug, debug, debug, debug, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugv, debugv, debugv, debugv, debugv, debugv, debugv, debugv, error, error, error, error, errorf, errorf, errorf, errorf, errorf, errorf, errorf, errorf, errorv, errorv, errorv, errorv, errorv, errorv, errorv, errorv, fatal, fatal, fatal, fatal, fatalf, fatalf, fatalf, fatalf, fatalf, fatalf, fatalf, fatalf, fatalv, fatalv, fatalv, fatalv, fatalv, fatalv, fatalv, fatalv, info, info, info, info, infof, infof, infof, infof, infof, infof, infof, infof, infov, infov, infov, infov, infov, infov, infov, infov, isDebugEnabled, isEnabled, isInfoEnabled, isTraceEnabled, log, log, log, log, logf, logf, logf, logf, logf, logf, logf, logf, logf, logf, logf, logf, logv, logv, logv, logv, logv, logv, logv, logv, logv, logv, logv, logv, trace, trace, trace, trace, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracev, tracev, tracev, tracev, tracev, tracev, tracev, tracev, warn, warn, warn, warn, warnf, warnf, warnf, warnf, warnf, warnf, warnf, warnf, warnv, warnv, warnv, warnv, warnv, warnv, warnv, warnv`

Method Detail

### alreadySessionBound

    @LogMessage(level=WARN)
    @Message(value="Already session bound on call to bind(); make sure you clean up your sessions!",
             id=2)
    void alreadySessionBound()

### autoCommitMode

    @LogMessage(level=INFO)
    @Message(value="Autocommit mode: %s",
             id=6)
    void autoCommitMode(boolean autocommit)

### autoFlushWillNotWork

    @LogMessage(level=WARN)
    @Message(value="JTASessionContext being used with JDBCTransactionFactory; auto-flush will not operate correctly with getCurrentSession()",
             id=8)
    void autoFlushWillNotWork()

### batchContainedStatementsOnRelease

    @LogMessage(level=INFO)
    @Message(value="On release of batch it still contained JDBC statements",
             id=10)
    void batchContainedStatementsOnRelease()

### bytecodeProvider

    @LogMessage(level=INFO)
    @Message(value="Bytecode provider name : %s",
             id=21)
    void bytecodeProvider(String provider)

### c3p0ProviderClassNotFound

    @LogMessage(level=WARN)
    @Message(value="c3p0 properties were encountered, but the %s provider class was not found on the classpath; these properties are going to be ignored.",
             id=22)
    void c3p0ProviderClassNotFound(String c3p0ProviderClassName)

### cachedFileNotFound

    @LogMessage(level=WARN)
    @Message(value="I/O reported cached file could not be found : %s : %s",
             id=23)
    void cachedFileNotFound(String path,
                                               FileNotFoundException error)

### cacheProvider

    @LogMessage(level=INFO)
    @Message(value="Cache provider: %s",
             id=24)
    void cacheProvider(String name)

### callingJoinTransactionOnNonJtaEntityManager

    @LogMessage(level=WARN)
    @Message(value="Calling joinTransaction() on a non JTA EntityManager",
             id=27)
    void callingJoinTransactionOnNonJtaEntityManager()

### cleaningUpConnectionPool

    @LogMessage(level=INFO)
    @Message(value="Cleaning up connection pool [%s]",
             id=30)
    void cleaningUpConnectionPool(String url)

### closing

    @LogMessage(level=DEBUG)
    @Message(value="Closing",
             id=31)
    void closing()

### collectionsFetched

    @LogMessage(level=INFO)
    @Message(value="Collections fetched (minimize this): %s",
             id=32)
    void collectionsFetched(long collectionFetchCount)

### collectionsLoaded

    @LogMessage(level=INFO)
    @Message(value="Collections loaded: %s",
             id=33)
    void collectionsLoaded(long collectionLoadCount)

### collectionsRecreated

    @LogMessage(level=INFO)
    @Message(value="Collections recreated: %s",
             id=34)
    void collectionsRecreated(long collectionRecreateCount)

### collectionsRemoved

    @LogMessage(level=INFO)
    @Message(value="Collections removed: %s",
             id=35)
    void collectionsRemoved(long collectionRemoveCount)

### collectionsUpdated

    @LogMessage(level=INFO)
    @Message(value="Collections updated: %s",
             id=36)
    void collectionsUpdated(long collectionUpdateCount)

### columns

    @LogMessage(level=INFO)
    @Message(value="Columns: %s",
             id=37)
    void columns(Set keySet)

### compositeIdClassDoesNotOverrideEquals

    @LogMessage(level=WARN)
    @Message(value="Composite-id class does not override equals(): %s",
             id=38)
    void compositeIdClassDoesNotOverrideEquals(String name)

### compositeIdClassDoesNotOverrideHashCode

    @LogMessage(level=WARN)
    @Message(value="Composite-id class does not override hashCode(): %s",
             id=39)
    void compositeIdClassDoesNotOverrideHashCode(String name)

### configurationResource

    @LogMessage(level=INFO)
    @Message(value="Configuration resource: %s",
             id=40)
    void configurationResource(String resource)

### configuredSessionFactory

    @LogMessage(level=INFO)
    @Message(value="Configured SessionFactory: %s",
             id=41)
    void configuredSessionFactory(String name)

### configuringFromFile

    @LogMessage(level=INFO)
    @Message(value="Configuring from file: %s",
             id=42)
    void configuringFromFile(String file)

### configuringFromResource

    @LogMessage(level=INFO)
    @Message(value="Configuring from resource: %s",
             id=43)
    void configuringFromResource(String resource)

### configuringFromUrl

    @LogMessage(level=INFO)
    @Message(value="Configuring from URL: %s",
             id=44)
    void configuringFromUrl(URL url)

### configuringFromXmlDocument

    @LogMessage(level=INFO)
    @Message(value="Configuring from XML document",
             id=45)
    void configuringFromXmlDocument()

### connectionProperties

    @LogMessage(level=INFO)
    @Message(value="Connection properties: %s",
             id=46)
    void connectionProperties(Properties connectionProps)

### connectionsObtained

    @LogMessage(level=INFO)
    @Message(value="Connections obtained: %s",
             id=48)
    void connectionsObtained(long connectCount)

### containerProvidingNullPersistenceUnitRootUrl

    @LogMessage(level=ERROR)
    @Message(value="Container is providing a null PersistenceUnitRootUrl: discovery impossible",
             id=50)
    void containerProvidingNullPersistenceUnitRootUrl()

### containsJoinFetchedCollection

    @LogMessage(level=WARN)
    @Message(value="Ignoring bag join fetch [%s] due to prior collection join fetch",
             id=51)
    void containsJoinFetchedCollection(String role)

### creatingSubcontextInfo

    @LogMessage(level=INFO)
    @Message(value="Creating subcontext: %s",
             id=53)
    void creatingSubcontextInfo(String intermediateContextName)

### definingFlushBeforeCompletionIgnoredInHem

    @LogMessage(level=WARN)
    @Message(value="Defining %s=true ignored in HEM",
             id=59)
    void definingFlushBeforeCompletionIgnoredInHem(String flushBeforeCompletion)

### deprecatedForceDescriminatorAnnotation

    @LogMessage(level=WARN)
    @Message(value="@ForceDiscriminator is deprecated use @DiscriminatorOptions instead.",
             id=62)
    void deprecatedForceDescriminatorAnnotation()

### deprecatedOracle9Dialect

    @LogMessage(level=WARN)
    @Message(value="The Oracle9Dialect dialect has been deprecated; use either Oracle9iDialect or Oracle10gDialect instead",
             id=63)
    void deprecatedOracle9Dialect()

### deprecatedOracleDialect

    @LogMessage(level=WARN)
    @Message(value="The OracleDialect dialect has been deprecated; use Oracle8iDialect instead",
             id=64)
    void deprecatedOracleDialect()

### deprecatedUuidGenerator

    @LogMessage(level=WARN)
    @Message(value="DEPRECATED : use [%s] instead with custom [%s] implementation",
             id=65)
    void deprecatedUuidGenerator(String name,
                                                    String name2)

### disallowingInsertStatementComment

    @LogMessage(level=INFO)
    @Message(value="Disallowing insert statement comment for select-identity due to Oracle driver bug",
             id=67)
    void disallowingInsertStatementComment()

### duplicateGeneratorName

    @LogMessage(level=WARN)
    @Message(value="Duplicate generator name %s",
             id=69)
    void duplicateGeneratorName(String name)

### duplicateGeneratorTable

    @LogMessage(level=WARN)
    @Message(value="Duplicate generator table: %s",
             id=70)
    void duplicateGeneratorTable(String name)

### duplicateImport

    @LogMessage(level=INFO)
    @Message(value="Duplicate import: %s -> %s",
             id=71)
    void duplicateImport(String entityName,
                                            String rename)

### duplicateJoins

    @LogMessage(level=WARN)
    @Message(value="Duplicate joins for class: %s",
             id=72)
    void duplicateJoins(String entityName)

### duplicateListener

    @LogMessage(level=INFO)
    @Message(value="entity-listener duplication, first event definition will be used: %s",
             id=73)
    void duplicateListener(String className)

### duplicateMetadata

    @LogMessage(level=WARN)
    @Message(value="Found more than one , subsequent ignored",
             id=74)
    void duplicateMetadata()

### entitiesDeleted

    @LogMessage(level=INFO)
    @Message(value="Entities deleted: %s",
             id=76)
    void entitiesDeleted(long entityDeleteCount)

### entitiesFetched

    @LogMessage(level=INFO)
    @Message(value="Entities fetched (minimize this): %s",
             id=77)
    void entitiesFetched(long entityFetchCount)

### entitiesInserted

    @LogMessage(level=INFO)
    @Message(value="Entities inserted: %s",
             id=78)
    void entitiesInserted(long entityInsertCount)

### entitiesLoaded

    @LogMessage(level=INFO)
    @Message(value="Entities loaded: %s",
             id=79)
    void entitiesLoaded(long entityLoadCount)

### entitiesUpdated

    @LogMessage(level=INFO)
    @Message(value="Entities updated: %s",
             id=80)
    void entitiesUpdated(long entityUpdateCount)

### entityAnnotationOnNonRoot

    @LogMessage(level=WARN)
    @Message(value="@org.hibernate.annotations.Entity used on a non root entity: ignored for %s",
             id=81)
    void entityAnnotationOnNonRoot(String className)

### entityManagerClosedBySomeoneElse

    @LogMessage(level=WARN)
    @Message(value="Entity Manager closed by someone else (%s must not be used)",
             id=82)
    void entityManagerClosedBySomeoneElse(String autoCloseSession)

### entityMappedAsNonAbstract

    @LogMessage(level=WARN)
    @Message(value="Entity [%s] is abstract-class/interface explicitly mapped as non-abstract; be sure to supply entity-names",
             id=84)
    void entityMappedAsNonAbstract(String name)

### exceptionHeaderFound

    @LogMessage(level=INFO)
    @Message(value="%s %s found",
             id=85)
    void exceptionHeaderFound(String exceptionHeader,
                                                 String metaInfOrmXml)

### exceptionHeaderNotFound

    @LogMessage(level=INFO)
    @Message(value="%s No %s found",
             id=86)
    void exceptionHeaderNotFound(String exceptionHeader,
                                                    String metaInfOrmXml)

### exceptionInAfterTransactionCompletionInterceptor

    @LogMessage(level=ERROR)
    @Message(value="Exception in interceptor afterTransactionCompletion()",
             id=87)
    void exceptionInAfterTransactionCompletionInterceptor(@Cause
                                                                             Throwable e)

### exceptionInBeforeTransactionCompletionInterceptor

    @LogMessage(level=ERROR)
    @Message(value="Exception in interceptor beforeTransactionCompletion()",
             id=88)
    void exceptionInBeforeTransactionCompletionInterceptor(@Cause
                                                                              Throwable e)

### exceptionInSubResolver

    @LogMessage(level=INFO)
    @Message(value="Sub-resolver threw unexpected exception, continuing to next : %s",
             id=89)
    void exceptionInSubResolver(String message)

### expectedType

    @LogMessage(level=ERROR)
    @Message(value="Expected type: %s, actual value: %s",
             id=91)
    void expectedType(String name,
                                         String string)

### expired

    @LogMessage(level=WARN)
    @Message(value="An item was expired by the cache while it was locked (increase your cache timeout): %s",
             id=92)
    void expired(Object key)

### factoryBoundToJndiName

    @LogMessage(level=INFO)
    @Message(value="Bound factory to JNDI name: %s",
             id=94)
    void factoryBoundToJndiName(String name)

### factoryJndiRename

    @LogMessage(level=INFO)
    @Message(value="A factory was renamed from [%s] to [%s] in JNDI",
             id=96)
    void factoryJndiRename(String oldName,
                                              String newName)

### factoryUnboundFromJndiName

    @LogMessage(level=INFO)
    @Message(value="Unbound factory from JNDI name: %s",
             id=97)
    void factoryUnboundFromJndiName(String name)

### factoryUnboundFromName

    @LogMessage(level=INFO)
    @Message(value="A factory was unbound from name: %s",
             id=98)
    void factoryUnboundFromName(String name)

### failed

    @LogMessage(level=ERROR)
    @Message(value="an assertion failure occured (this may indicate a bug in Hibernate, but is more likely due to unsafe use of the session): %s",
             id=99)
    void failed(Throwable throwable)

### failSafeCollectionsCleanup

    @LogMessage(level=WARN)
    @Message(value="Fail-safe cleanup (collections) : %s",
             id=100)
    void failSafeCollectionsCleanup(CollectionLoadContext collectionLoadContext)

### failSafeEntitiesCleanup

    @LogMessage(level=WARN)
    @Message(value="Fail-safe cleanup (entities) : %s",
             id=101)
    void failSafeEntitiesCleanup(EntityLoadContext entityLoadContext)

### fetchingDatabaseMetadata

    @LogMessage(level=INFO)
    @Message(value="Fetching database metadata",
             id=102)
    void fetchingDatabaseMetadata()

### filterAnnotationOnSubclass

    @LogMessage(level=WARN)
    @Message(value="@Filter not allowed on subclasses (ignored): %s",
             id=103)
    void filterAnnotationOnSubclass(String className)

### firstOrMaxResultsSpecifiedWithCollectionFetch

    @LogMessage(level=WARN)
    @Message(value="firstResult/maxResults specified with collection fetch; applying in memory!",
             id=104)
    void firstOrMaxResultsSpecifiedWithCollectionFetch()

### flushes

    @LogMessage(level=INFO)
    @Message(value="Flushes: %s",
             id=105)
    void flushes(long flushCount)

### forcingContainerResourceCleanup

    @LogMessage(level=INFO)
    @Message(value="Forcing container resource cleanup on transaction completion",
             id=106)
    void forcingContainerResourceCleanup()

### forcingTableUse

    @LogMessage(level=INFO)
    @Message(value="Forcing table use for sequence-style generator due to pooled optimizer selection where db does not support pooled sequences",
             id=107)
    void forcingTableUse()

### foreignKeys

    @LogMessage(level=INFO)
    @Message(value="Foreign keys: %s",
             id=108)
    void foreignKeys(Set keySet)

### foundMappingDocument

    @LogMessage(level=INFO)
    @Message(value="Found mapping document in jar: %s",
             id=109)
    void foundMappingDocument(String name)

### gettersOfLazyClassesCannotBeFinal

    @LogMessage(level=ERROR)
    @Message(value="Getters of lazy classes cannot be final: %s.%s",
             id=112)
    void gettersOfLazyClassesCannotBeFinal(String entityName,
                                                              String name)

### guidGenerated

    @LogMessage(level=WARN)
    @Message(value="GUID identifier generated: %s",
             id=113)
    void guidGenerated(String result)

### handlingTransientEntity

    @LogMessage(level=INFO)
    @Message(value="Handling transient entity in delete processing",
             id=114)
    void handlingTransientEntity()

### hibernateConnectionPoolSize

    @LogMessage(level=INFO)
    @Message(value="Hibernate connection pool size: %s",
             id=115)
    void hibernateConnectionPoolSize(int poolSize)

### honoringOptimizerSetting

    @LogMessage(level=WARN)
    @Message(value="Config specified explicit optimizer of [%s], but [%s=%s; honoring optimizer setting",
             id=116)
    void honoringOptimizerSetting(String none,
                                                     String incrementParam,
                                                     int incrementSize)

### hql

    @LogMessage(level=DEBUG)
    @Message(value="HQL: %s, time: %sms, rows: %s",
             id=117)
    void hql(String hql,
                                Long valueOf,
                                Long valueOf2)

### hsqldbSupportsOnlyReadCommittedIsolation

    @LogMessage(level=WARN)
    @Message(value="HSQLDB supports only READ_UNCOMMITTED isolation",
             id=118)
    void hsqldbSupportsOnlyReadCommittedIsolation()

### hydratingEntitiesCount

    @LogMessage(level=WARN)
    @Message(value="On EntityLoadContext#clear, hydratingEntities contained [%s] entries",
             id=119)
    void hydratingEntitiesCount(int size)

### ignoringTableGeneratorConstraints

    @LogMessage(level=WARN)
    @Message(value="Ignoring unique constraints specified on table generator [%s]",
             id=120)
    void ignoringTableGeneratorConstraints(String name)

### ignoringUnrecognizedQueryHint

    @LogMessage(level=INFO)
    @Message(value="Ignoring unrecognized query hint [%s]",
             id=121)
    void ignoringUnrecognizedQueryHint(String hintName)

### illegalPropertyGetterArgument

    @LogMessage(level=ERROR)
    @Message(value="IllegalArgumentException in class: %s, getter method of property: %s",
             id=122)
    void illegalPropertyGetterArgument(String name,
                                                          String propertyName)

### illegalPropertySetterArgument

    @LogMessage(level=ERROR)
    @Message(value="IllegalArgumentException in class: %s, setter method of property: %s",
             id=123)
    void illegalPropertySetterArgument(String name,
                                                          String propertyName)

### immutableAnnotationOnNonRoot

    @LogMessage(level=WARN)
    @Message(value="@Immutable used on a non root entity: ignored for %s",
             id=124)
    void immutableAnnotationOnNonRoot(String className)

### incompleteMappingMetadataCacheProcessing

    @LogMessage(level=WARN)
    @Message(value="Mapping metadata cache was not completely processed",
             id=125)
    void incompleteMappingMetadataCacheProcessing()

### indexes

    @LogMessage(level=INFO)
    @Message(value="Indexes: %s",
             id=126)
    void indexes(Set keySet)

### couldNotBindJndiListener

    @LogMessage(level=DEBUG)
    @Message(value="Could not bind JNDI listener",
             id=127)
    void couldNotBindJndiListener()

### instantiatingExplicitConnectionProvider

    @LogMessage(level=INFO)
    @Message(value="Instantiating explicit connection provider: %s",
             id=130)
    void instantiatingExplicitConnectionProvider(String providerClassName)

### invalidArrayElementType

    @LogMessage(level=ERROR)
    @Message(value="Array element type error\n%s",
             id=132)
    void invalidArrayElementType(String message)

### invalidDiscriminatorAnnotation

    @LogMessage(level=WARN)
    @Message(value="Discriminator column has to be defined in the root entity, it will be ignored in subclass: %s",
             id=133)
    void invalidDiscriminatorAnnotation(String className)

### invalidEditOfReadOnlyItem

    @LogMessage(level=ERROR)
    @Message(value="Application attempted to edit read only item: %s",
             id=134)
    void invalidEditOfReadOnlyItem(Object key)

### invalidJndiName

    @LogMessage(level=ERROR)
    @Message(value="Invalid JNDI name: %s",
             id=135)
    void invalidJndiName(String name,
                                            @Cause
                                            JndiNameException e)

### invalidOnDeleteAnnotation

    @LogMessage(level=WARN)
    @Message(value="Inapropriate use of @OnDelete on entity, annotation ignored: %s",
             id=136)
    void invalidOnDeleteAnnotation(String entityName)

### invalidPrimaryKeyJoinColumnAnnotation

    @LogMessage(level=WARN)
    @Message(value="Root entity should not hold an PrimaryKeyJoinColum(s), will be ignored",
             id=137)
    void invalidPrimaryKeyJoinColumnAnnotation()

### invalidSubStrategy

    @LogMessage(level=WARN)
    @Message(value="Mixing inheritance strategy in a entity hierarchy is not allowed, ignoring sub strategy in: %s",
             id=138)
    void invalidSubStrategy(String className)

### invalidTableAnnotation

    @LogMessage(level=WARN)
    @Message(value="Illegal use of @Table in a subclass of a SINGLE_TABLE hierarchy: %s",
             id=139)
    void invalidTableAnnotation(String className)

### jaccContextId

    @LogMessage(level=INFO)
    @Message(value="JACC contextID: %s",
             id=140)
    void jaccContextId(String contextId)

### JavaSqlTypesMappedSameCodeMultipleTimes

    @LogMessage(level=INFO)
    @Message(value="java.sql.Types mapped the same code [%s] multiple times; was [%s]; now [%s]",
             id=141)
    void JavaSqlTypesMappedSameCodeMultipleTimes(int code,
                                                                    String old,
                                                                    String name)

### javassistEnhancementFailed

    @Message(value="Javassist Enhancement failed: %s",
             id=142)
    String javassistEnhancementFailed(String entityName)

### jdbcAutoCommitFalseBreaksEjb3Spec

    @LogMessage(level=WARN)
    @Message(value="%s = false breaks the EJB3 specification",
             id=144)
    void jdbcAutoCommitFalseBreaksEjb3Spec(String autocommit)

### jdbcDriverNotSpecified

    @LogMessage(level=WARN)
    @Message(value="No JDBC Driver class was specified by property %s",
             id=148)
    void jdbcDriverNotSpecified(String driver)

### jdbcIsolationLevel

    @LogMessage(level=INFO)
    @Message(value="JDBC isolation level: %s",
             id=149)
    void jdbcIsolationLevel(String isolationLevelToString)

### jdbcRollbackFailed

    @Message(value="JDBC rollback failed",
             id=151)
    String jdbcRollbackFailed()

### jdbcUrlNotSpecified

    @Message(value="JDBC URL was not specified by property %s",
             id=152)
    String jdbcUrlNotSpecified(String url)

### jndiInitialContextProperties

    @LogMessage(level=INFO)
    @Message(value="JNDI InitialContext properties:%s",
             id=154)
    void jndiInitialContextProperties(Hashtable hash)

### jndiNameDoesNotHandleSessionFactoryReference

    @LogMessage(level=ERROR)
    @Message(value="JNDI name %s does not handle a session factory reference",
             id=155)
    void jndiNameDoesNotHandleSessionFactoryReference(String sfJNDIName,
                                                                         @Cause
                                                                         ClassCastException e)

### lazyPropertyFetchingAvailable

    @LogMessage(level=INFO)
    @Message(value="Lazy property fetching available for: %s",
             id=157)
    void lazyPropertyFetchingAvailable(String name)

### loadingCollectionKeyNotFound

    @LogMessage(level=WARN)
    @Message(value="In CollectionLoadContext#endLoadingCollections, localLoadingCollectionKeys contained [%s], but no LoadingCollectionEntry was found in loadContexts",
             id=159)
    void loadingCollectionKeyNotFound(CollectionKey collectionKey)

### localLoadingCollectionKeysCount

    @LogMessage(level=WARN)
    @Message(value="On CollectionLoadContext#cleanup, localLoadingCollectionKeys contained [%s] entries",
             id=160)
    void localLoadingCollectionKeysCount(int size)

### loggingStatistics

    @LogMessage(level=INFO)
    @Message(value="Logging statistics....",
             id=161)
    void loggingStatistics()

### logicalConnectionClosed

    @LogMessage(level=DEBUG)
    @Message(value="*** Logical connection closed ***",
             id=162)
    void logicalConnectionClosed()

### logicalConnectionReleasingPhysicalConnection

    @LogMessage(level=DEBUG)
    @Message(value="Logical connection releasing its physical connection",
             id=163)
    void logicalConnectionReleasingPhysicalConnection()

### maxQueryTime

    @LogMessage(level=INFO)
    @Message(value="Max query time: %sms",
             id=173)
    void maxQueryTime(long queryExecutionMaxTime)

### missingArguments

    @LogMessage(level=WARN)
    @Message(value="Function template anticipated %s arguments, but %s arguments encountered",
             id=174)
    void missingArguments(int anticipatedNumberOfArguments,
                                             int numberOfArguments)

### missingEntityAnnotation

    @LogMessage(level=WARN)
    @Message(value="Class annotated @org.hibernate.annotations.Entity but not javax.persistence.Entity (most likely a user error): %s",
             id=175)
    void missingEntityAnnotation(String className)

### namedQueryError

    @LogMessage(level=ERROR)
    @Message(value="Error in named query: %s",
             id=177)
    void namedQueryError(String queryName,
                                            @Cause
                                            HibernateException e)

### namingExceptionAccessingFactory

    @LogMessage(level=WARN)
    @Message(value="Naming exception occurred accessing factory: %s",
             id=178)
    void namingExceptionAccessingFactory(NamingException exception)

### narrowingProxy

    @LogMessage(level=WARN)
    @Message(value="Narrowing proxy to %s - this operation breaks ==",
             id=179)
    void narrowingProxy(Class concreteProxyClass)

### needsLimit

    @LogMessage(level=WARN)
    @Message(value="FirstResult/maxResults specified on polymorphic query; applying in memory!",
             id=180)
    void needsLimit()

### noAppropriateConnectionProvider

    @LogMessage(level=WARN)
    @Message(value="No appropriate connection provider encountered, assuming application will be supplying connections",
             id=181)
    void noAppropriateConnectionProvider()

### noDefaultConstructor

    @LogMessage(level=INFO)
    @Message(value="No default (no-argument) constructor for class: %s (class must be instantiated by Interceptor)",
             id=182)
    void noDefaultConstructor(String name)

### noPersistentClassesFound

    @LogMessage(level=WARN)
    @Message(value="no persistent classes found for query class: %s",
             id=183)
    void noPersistentClassesFound(String query)

### noSessionFactoryWithJndiName

    @LogMessage(level=ERROR)
    @Message(value="No session factory with JNDI name %s",
             id=184)
    void noSessionFactoryWithJndiName(String sfJNDIName,
                                                         @Cause
                                                         NameNotFoundException e)

### optimisticLockFailures

    @LogMessage(level=INFO)
    @Message(value="Optimistic lock failures: %s",
             id=187)
    void optimisticLockFailures(long optimisticFailureCount)

### orderByAnnotationIndexedCollection

    @LogMessage(level=WARN)
    @Message(value="@OrderBy not allowed for an indexed collection, annotation ignored.",
             id=189)
    void orderByAnnotationIndexedCollection()

### overridingTransactionStrategyDangerous

    @LogMessage(level=WARN)
    @Message(value="Overriding %s is dangerous, this might break the EJB3 specification implementation",
             id=193)
    void overridingTransactionStrategyDangerous(String transactionStrategy)

### packageNotFound

    @LogMessage(level=DEBUG)
    @Message(value="Package not found or wo package-info.java: %s",
             id=194)
    void packageNotFound(String packageName)

### parameterPositionOccurredAsBothJpaAndHibernatePositionalParameter

    @LogMessage(level=WARN)
    @Message(value="Parameter position [%s] occurred as both JPA and Hibernate positional parameter",
             id=195)
    void parameterPositionOccurredAsBothJpaAndHibernatePositionalParameter(Integer position)

### parsingXmlError

    @LogMessage(level=ERROR)
    @Message(value="Error parsing XML (%s) : %s",
             id=196)
    void parsingXmlError(int lineNumber,
                                            String message)

### parsingXmlErrorForFile

    @LogMessage(level=ERROR)
    @Message(value="Error parsing XML: %s(%s) %s",
             id=197)
    void parsingXmlErrorForFile(String file,
                                                   int lineNumber,
                                                   String message)

### parsingXmlWarning

    @LogMessage(level=ERROR)
    @Message(value="Warning parsing XML (%s) : %s",
             id=198)
    void parsingXmlWarning(int lineNumber,
                                              String message)

### parsingXmlWarningForFile

    @LogMessage(level=WARN)
    @Message(value="Warning parsing XML: %s(%s) %s",
             id=199)
    void parsingXmlWarningForFile(String file,
                                                     int lineNumber,
                                                     String message)

### persistenceProviderCallerDoesNotImplementEjb3SpecCorrectly

    @LogMessage(level=WARN)
    @Message(value="Persistence provider caller does not implement the EJB3 spec correctly.PersistenceUnitInfo.getNewTempClassLoader() is null.",
             id=200)
    void persistenceProviderCallerDoesNotImplementEjb3SpecCorrectly()

### pooledOptimizerReportedInitialValue

    @LogMessage(level=INFO)
    @Message(value="Pooled optimizer source reported [%s] as the initial value; use of 1 or greater highly recommended",
             id=201)
    void pooledOptimizerReportedInitialValue(IntegralDataTypeHolder value)

### preparedStatementAlreadyInBatch

    @LogMessage(level=ERROR)
    @Message(value="PreparedStatement was already in the batch, [%s].",
             id=202)
    void preparedStatementAlreadyInBatch(String sql)

### processEqualityExpression

    @LogMessage(level=WARN)
    @Message(value="processEqualityExpression() : No expression to process!",
             id=203)
    void processEqualityExpression()

### processingPersistenceUnitInfoName

    @LogMessage(level=INFO)
    @Message(value="Processing PersistenceUnitInfo [\n\tname: %s\n\t...]",
             id=204)
    void processingPersistenceUnitInfoName(String persistenceUnitName)

### propertiesLoaded

    @LogMessage(level=INFO)
    @Message(value="Loaded properties from resource hibernate.properties: %s",
             id=205)
    void propertiesLoaded(Properties maskOut)

### propertiesNotFound

    @LogMessage(level=INFO)
    @Message(value="hibernate.properties not found",
             id=206)
    void propertiesNotFound()

### propertyNotFound

    @LogMessage(level=WARN)
    @Message(value="Property %s not found in class but described in  (possible typo error)",
             id=207)
    void propertyNotFound(String property)

### providerClassDeprecated

    @LogMessage(level=WARN)
    @Message(value="%s has been deprecated in favor of %s; that provider will be used instead.",
             id=208)
    void providerClassDeprecated(String providerClassName,
                                                    String actualProviderClassName)

### proxoolProviderClassNotFound

    @LogMessage(level=WARN)
    @Message(value="proxool properties were encountered, but the %s provider class was not found on the classpath; these properties are going to be ignored.",
             id=209)
    void proxoolProviderClassNotFound(String proxoolProviderClassName)

### queriesExecuted

    @LogMessage(level=INFO)
    @Message(value="Queries executed to database: %s",
             id=210)
    void queriesExecuted(long queryExecutionCount)

### queryCacheHits

    @LogMessage(level=INFO)
    @Message(value="Query cache hits: %s",
             id=213)
    void queryCacheHits(long queryCacheHitCount)

### queryCacheMisses

    @LogMessage(level=INFO)
    @Message(value="Query cache misses: %s",
             id=214)
    void queryCacheMisses(long queryCacheMissCount)

### queryCachePuts

    @LogMessage(level=INFO)
    @Message(value="Query cache puts: %s",
             id=215)
    void queryCachePuts(long queryCachePutCount)

### rdmsOs2200Dialect

    @LogMessage(level=INFO)
    @Message(value="RDMSOS2200Dialect version: 1.0",
             id=218)
    void rdmsOs2200Dialect()

### readingCachedMappings

    @LogMessage(level=INFO)
    @Message(value="Reading mappings from cache file: %s",
             id=219)
    void readingCachedMappings(File cachedFile)

### readingMappingsFromFile

    @LogMessage(level=INFO)
    @Message(value="Reading mappings from file: %s",
             id=220)
    void readingMappingsFromFile(String path)

### readingMappingsFromResource

    @LogMessage(level=INFO)
    @Message(value="Reading mappings from resource: %s",
             id=221)
    void readingMappingsFromResource(String resourceName)

### readOnlyCacheConfiguredForMutableCollection

    @LogMessage(level=WARN)
    @Message(value="read-only cache configured for mutable collection [%s]",
             id=222)
    void readOnlyCacheConfiguredForMutableCollection(String name)

### recognizedObsoleteHibernateNamespace

    @LogMessage(level=WARN)
    @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)

### renamedProperty

    @LogMessage(level=WARN)
    @Message(value="Property [%s] has been renamed to [%s]; update your properties appropriately",
             id=225)
    void renamedProperty(Object propertyName,
                                            Object newPropertyName)

### requiredDifferentProvider

    @LogMessage(level=INFO)
    @Message(value="Required a different provider: %s",
             id=226)
    void requiredDifferentProvider(String provider)

### runningHbm2ddlSchemaExport

    @LogMessage(level=INFO)
    @Message(value="Running hbm2ddl schema export",
             id=227)
    void runningHbm2ddlSchemaExport()

### runningHbm2ddlSchemaUpdate

    @LogMessage(level=INFO)
    @Message(value="Running hbm2ddl schema update",
             id=228)
    void runningHbm2ddlSchemaUpdate()

### runningSchemaValidator

    @LogMessage(level=INFO)
    @Message(value="Running schema validator",
             id=229)
    void runningSchemaValidator()

### schemaExportComplete

    @LogMessage(level=INFO)
    @Message(value="Schema export complete",
             id=230)
    void schemaExportComplete()

### schemaExportUnsuccessful

    @LogMessage(level=ERROR)
    @Message(value="Schema export unsuccessful",
             id=231)
    void schemaExportUnsuccessful(@Cause
                                                     Exception e)

### schemaUpdateComplete

    @LogMessage(level=INFO)
    @Message(value="Schema update complete",
             id=232)
    void schemaUpdateComplete()

### scopingTypesToSessionFactoryAfterAlreadyScoped

    @LogMessage(level=WARN)
    @Message(value="Scoping types to session factory %s after already scoped %s",
             id=233)
    void scopingTypesToSessionFactoryAfterAlreadyScoped(SessionFactoryImplementor factory,
                                                                           SessionFactoryImplementor factory2)

### searchingForMappingDocuments

    @LogMessage(level=INFO)
    @Message(value="Searching for mapping documents in jar: %s",
             id=235)
    void searchingForMappingDocuments(String name)

### secondLevelCacheHits

    @LogMessage(level=INFO)
    @Message(value="Second level cache hits: %s",
             id=237)
    void secondLevelCacheHits(long secondLevelCacheHitCount)

### secondLevelCacheMisses

    @LogMessage(level=INFO)
    @Message(value="Second level cache misses: %s",
             id=238)
    void secondLevelCacheMisses(long secondLevelCacheMissCount)

### secondLevelCachePuts

    @LogMessage(level=INFO)
    @Message(value="Second level cache puts: %s",
             id=239)
    void secondLevelCachePuts(long secondLevelCachePutCount)

### serviceProperties

    @LogMessage(level=INFO)
    @Message(value="Service properties: %s",
             id=240)
    void serviceProperties(Properties properties)

### sessionsClosed

    @LogMessage(level=INFO)
    @Message(value="Sessions closed: %s",
             id=241)
    void sessionsClosed(long sessionCloseCount)

### sessionsOpened

    @LogMessage(level=INFO)
    @Message(value="Sessions opened: %s",
             id=242)
    void sessionsOpened(long sessionOpenCount)

### settersOfLazyClassesCannotBeFinal

    @LogMessage(level=ERROR)
    @Message(value="Setters of lazy classes cannot be final: %s.%s",
             id=243)
    void settersOfLazyClassesCannotBeFinal(String entityName,
                                                              String name)

### sortAnnotationIndexedCollection

    @LogMessage(level=WARN)
    @Message(value="@Sort not allowed for an indexed collection, annotation ignored.",
             id=244)
    void sortAnnotationIndexedCollection()

### splitQueries

    @LogMessage(level=WARN)
    @Message(value="Manipulation query [%s] resulted in [%s] split queries",
             id=245)
    void splitQueries(String sourceQuery,
                                         int length)

### sqlExceptionEscapedProxy

    @LogMessage(level=ERROR)
    @Message(value="SQLException escaped proxy",
             id=246)
    void sqlExceptionEscapedProxy(@Cause
                                                     SQLException e)

### sqlWarning

    @LogMessage(level=WARN)
    @Message(value="SQL Error: %s, SQLState: %s",
             id=247)
    void sqlWarning(int errorCode,
                                       String sqlState)

### startingQueryCache

    @LogMessage(level=INFO)
    @Message(value="Starting query cache at region: %s",
             id=248)
    void startingQueryCache(String region)

### startingServiceAtJndiName

    @LogMessage(level=INFO)
    @Message(value="Starting service at JNDI name: %s",
             id=249)
    void startingServiceAtJndiName(String boundName)

### startingUpdateTimestampsCache

    @LogMessage(level=INFO)
    @Message(value="Starting update timestamps cache at region: %s",
             id=250)
    void startingUpdateTimestampsCache(String region)

### startTime

    @LogMessage(level=INFO)
    @Message(value="Start time: %s",
             id=251)
    void startTime(long startTime)

### statementsClosed

    @LogMessage(level=INFO)
    @Message(value="Statements closed: %s",
             id=252)
    void statementsClosed(long closeStatementCount)

### statementsPrepared

    @LogMessage(level=INFO)
    @Message(value="Statements prepared: %s",
             id=253)
    void statementsPrepared(long prepareStatementCount)

### stoppingService

    @LogMessage(level=INFO)
    @Message(value="Stopping service",
             id=255)
    void stoppingService()

### subResolverException

    @LogMessage(level=INFO)
    @Message(value="sub-resolver threw unexpected exception, continuing to next : %s",
             id=257)
    void subResolverException(String message)

### successfulTransactions

    @LogMessage(level=INFO)
    @Message(value="Successful transactions: %s",
             id=258)
    void successfulTransactions(long committedTransactionCount)

### synchronizationAlreadyRegistered

    @LogMessage(level=INFO)
    @Message(value="Synchronization [%s] was already registered",
             id=259)
    void synchronizationAlreadyRegistered(Synchronization synchronization)

### synchronizationFailed

    @LogMessage(level=ERROR)
    @Message(value="Exception calling user Synchronization [%s] : %s",
             id=260)
    void synchronizationFailed(Synchronization synchronization,
                                                  Throwable t)

### tableFound

    @LogMessage(level=INFO)
    @Message(value="Table found: %s",
             id=261)
    void tableFound(String string)

### tableNotFound

    @LogMessage(level=INFO)
    @Message(value="Table not found: %s",
             id=262)
    void tableNotFound(String name)

### transactions

    @LogMessage(level=INFO)
    @Message(value="Transactions: %s",
             id=266)
    void transactions(long transactionCount)

### transactionStartedOnNonRootSession

    @LogMessage(level=WARN)
    @Message(value="Transaction started on non-root session",
             id=267)
    void transactionStartedOnNonRootSession()

### transactionStrategy

    @LogMessage(level=INFO)
    @Message(value="Transaction strategy: %s",
             id=268)
    void transactionStrategy(String strategyClassName)

### typeDefinedNoRegistrationKeys

    @LogMessage(level=WARN)
    @Message(value="Type [%s] defined no registration keys; ignoring",
             id=269)
    void typeDefinedNoRegistrationKeys(BasicType type)

### typeRegistrationOverridesPrevious

    @LogMessage(level=INFO)
    @Message(value="Type registration [%s] overrides previous : %s",
             id=270)
    void typeRegistrationOverridesPrevious(String key,
                                                              Type old)

### unableToAccessEjb3Configuration

    @LogMessage(level=WARN)
    @Message(value="Naming exception occurred accessing Ejb3Configuration",
             id=271)
    void unableToAccessEjb3Configuration(@Cause
                                                            NamingException e)

### unableToAccessSessionFactory

    @LogMessage(level=ERROR)
    @Message(value="Error while accessing session factory with JNDI name %s",
             id=272)
    void unableToAccessSessionFactory(String sfJNDIName,
                                                         @Cause
                                                         NamingException e)

### unableToAccessTypeInfoResultSet

    @LogMessage(level=WARN)
    @Message(value="Error accessing type info result set : %s",
             id=273)
    void unableToAccessTypeInfoResultSet(String string)

### unableToApplyConstraints

    @LogMessage(level=WARN)
    @Message(value="Unable to apply constraints on DDL for %s",
             id=274)
    void unableToApplyConstraints(String className,
                                                     @Cause
                                                     Exception e)

### unableToBindEjb3ConfigurationToJndi

    @LogMessage(level=WARN)
    @Message(value="Could not bind Ejb3Configuration to JNDI",
             id=276)
    void unableToBindEjb3ConfigurationToJndi(@Cause
                                                                JndiException e)

### unableToBindFactoryToJndi

    @LogMessage(level=WARN)
    @Message(value="Could not bind factory to JNDI",
             id=277)
    void unableToBindFactoryToJndi(@Cause
                                                      JndiException e)

### unableToBindValueToParameter

    @LogMessage(level=INFO)
    @Message(value="Could not bind value \'%s\' to parameter: %s; %s",
             id=278)
    void unableToBindValueToParameter(String nullSafeToString,
                                                         int index,
                                                         String message)

### unableToBuildEnhancementMetamodel

    @LogMessage(level=ERROR)
    @Message(value="Unable to build enhancement metamodel for %s",
             id=279)
    void unableToBuildEnhancementMetamodel(String className)

### unableToBuildSessionFactoryUsingMBeanClasspath

    @LogMessage(level=INFO)
    @Message(value="Could not build SessionFactory using the MBean classpath - will try again using client classpath: %s",
             id=280)
    void unableToBuildSessionFactoryUsingMBeanClasspath(String message)

### unableToCleanUpCallableStatement

    @LogMessage(level=WARN)
    @Message(value="Unable to clean up callable statement",
             id=281)
    void unableToCleanUpCallableStatement(@Cause
                                                             SQLException e)

### unableToCleanUpPreparedStatement

    @LogMessage(level=WARN)
    @Message(value="Unable to clean up prepared statement",
             id=282)
    void unableToCleanUpPreparedStatement(@Cause
                                                             SQLException e)

### unableToCleanupTemporaryIdTable

    @LogMessage(level=WARN)
    @Message(value="Unable to cleanup temporary id table after use [%s]",
             id=283)
    void unableToCleanupTemporaryIdTable(Throwable t)

### unableToCloseConnection

    @LogMessage(level=ERROR)
    @Message(value="Error closing connection",
             id=284)
    void unableToCloseConnection(@Cause
                                                    Exception e)

### unableToCloseInitialContext

    @LogMessage(level=INFO)
    @Message(value="Error closing InitialContext [%s]",
             id=285)
    void unableToCloseInitialContext(String string)

### unableToCloseInputFiles

    @LogMessage(level=ERROR)
    @Message(value="Error closing input files: %s",
             id=286)
    void unableToCloseInputFiles(String name,
                                                    @Cause
                                                    IOException e)

### unableToCloseInputStream

    @LogMessage(level=WARN)
    @Message(value="Could not close input stream",
             id=287)
    void unableToCloseInputStream(@Cause
                                                     IOException e)

### unableToCloseInputStreamForResource

    @LogMessage(level=WARN)
    @Message(value="Could not close input stream for %s",
             id=288)
    void unableToCloseInputStreamForResource(String resourceName,
                                                                @Cause
                                                                IOException e)

### unableToCloseIterator

    @LogMessage(level=INFO)
    @Message(value="Unable to close iterator",
             id=289)
    void unableToCloseIterator(@Cause
                                                  SQLException e)

### unableToCloseJar

    @LogMessage(level=ERROR)
    @Message(value="Could not close jar: %s",
             id=290)
    void unableToCloseJar(String message)

### unableToCloseOutputFile

    @LogMessage(level=ERROR)
    @Message(value="Error closing output file: %s",
             id=291)
    void unableToCloseOutputFile(String outputFile,
                                                    @Cause
                                                    IOException e)

### unableToCloseOutputStream

    @LogMessage(level=WARN)
    @Message(value="IOException occurred closing output stream",
             id=292)
    void unableToCloseOutputStream(@Cause
                                                      IOException e)

### unableToClosePooledConnection

    @LogMessage(level=WARN)
    @Message(value="Problem closing pooled connection",
             id=293)
    void unableToClosePooledConnection(@Cause
                                                          SQLException e)

### unableToCloseSession

    @LogMessage(level=ERROR)
    @Message(value="Could not close session",
             id=294)
    void unableToCloseSession(@Cause
                                                 HibernateException e)

### unableToCloseSessionDuringRollback

    @LogMessage(level=ERROR)
    @Message(value="Could not close session during rollback",
             id=295)
    void unableToCloseSessionDuringRollback(@Cause
                                                               Exception e)

### unableToCloseStream

    @LogMessage(level=WARN)
    @Message(value="IOException occurred closing stream",
             id=296)
    void unableToCloseStream(@Cause
                                                IOException e)

### unableToCloseStreamError

    @LogMessage(level=ERROR)
    @Message(value="Could not close stream on hibernate.properties: %s",
             id=297)
    void unableToCloseStreamError(IOException error)

### unableToCommitJta

    @Message(value="JTA commit failed",
             id=298)
    String unableToCommitJta()

### unableToCompleteSchemaUpdate

    @LogMessage(level=ERROR)
    @Message(value="Could not complete schema update",
             id=299)
    void unableToCompleteSchemaUpdate(@Cause
                                                         Exception e)

### unableToCompleteSchemaValidation

    @LogMessage(level=ERROR)
    @Message(value="Could not complete schema validation",
             id=300)
    void unableToCompleteSchemaValidation(@Cause
                                                             SQLException e)

### unableToConfigureSqlExceptionConverter

    @LogMessage(level=WARN)
    @Message(value="Unable to configure SQLExceptionConverter : %s",
             id=301)
    void unableToConfigureSqlExceptionConverter(HibernateException e)

### unableToConstructCurrentSessionContext

    @LogMessage(level=ERROR)
    @Message(value="Unable to construct current session context [%s]",
             id=302)
    void unableToConstructCurrentSessionContext(String impl,
                                                                   @Cause
                                                                   Throwable e)

### unableToConstructSqlExceptionConverter

    @LogMessage(level=WARN)
    @Message(value="Unable to construct instance of specified SQLExceptionConverter : %s",
             id=303)
    void unableToConstructSqlExceptionConverter(Throwable t)

### unableToCopySystemProperties

    @LogMessage(level=WARN)
    @Message(value="Could not copy system properties, system properties will be ignored",
             id=304)
    void unableToCopySystemProperties()

### unableToCreateProxyFactory

    @LogMessage(level=WARN)
    @Message(value="Could not create proxy factory for:%s",
             id=305)
    void unableToCreateProxyFactory(String entityName,
                                                       @Cause
                                                       HibernateException e)

### unableToCreateSchema

    @LogMessage(level=ERROR)
    @Message(value="Error creating schema ",
             id=306)
    void unableToCreateSchema(@Cause
                                                 Exception e)

### unableToDeserializeCache

    @LogMessage(level=WARN)
    @Message(value="Could not deserialize cache file: %s : %s",
             id=307)
    void unableToDeserializeCache(String path,
                                                     SerializationException error)

### unableToDestroyCache

    @LogMessage(level=WARN)
    @Message(value="Unable to destroy cache: %s",
             id=308)
    void unableToDestroyCache(String message)

### unableToDestroyQueryCache

    @LogMessage(level=WARN)
    @Message(value="Unable to destroy query cache: %s: %s",
             id=309)
    void unableToDestroyQueryCache(String region,
                                                      String message)

### unableToDestroyUpdateTimestampsCache

    @LogMessage(level=WARN)
    @Message(value="Unable to destroy update timestamps cache: %s: %s",
             id=310)
    void unableToDestroyUpdateTimestampsCache(String region,
                                                                 String message)

### unableToDetermineLockModeValue

    @LogMessage(level=INFO)
    @Message(value="Unable to determine lock mode value : %s -> %s",
             id=311)
    void unableToDetermineLockModeValue(String hintName,
                                                           Object value)

### unableToDetermineTransactionStatus

    @Message(value="Could not determine transaction status",
             id=312)
    String unableToDetermineTransactionStatus()

### unableToDetermineTransactionStatusAfterCommit

    @Message(value="Could not determine transaction status after commit",
             id=313)
    String unableToDetermineTransactionStatusAfterCommit()

### unableToDropTemporaryIdTable

    @LogMessage(level=WARN)
    @Message(value="Unable to drop temporary id table after use [%s]",
             id=314)
    void unableToDropTemporaryIdTable(String message)

### unableToExecuteBatch

    @LogMessage(level=ERROR)
    @Message(value="Exception executing batch [%s]",
             id=315)
    void unableToExecuteBatch(String message)

### unableToExecuteResolver

    @LogMessage(level=WARN)
    @Message(value="Error executing resolver [%s] : %s",
             id=316)
    void unableToExecuteResolver(AbstractDialectResolver abstractDialectResolver,
                                                    String message)

### unableToFindPersistenceXmlInClasspath

    @LogMessage(level=INFO)
    @Message(value="Could not find any META-INF/persistence.xml file in the classpath",
             id=318)
    void unableToFindPersistenceXmlInClasspath()

### unableToGetDatabaseMetadata

    @LogMessage(level=ERROR)
    @Message(value="Could not get database metadata",
             id=319)
    void unableToGetDatabaseMetadata(@Cause
                                                        SQLException e)

### unableToInstantiateConfiguredSchemaNameResolver

    @LogMessage(level=WARN)
    @Message(value="Unable to instantiate configured schema name resolver [%s] %s",
             id=320)
    void unableToInstantiateConfiguredSchemaNameResolver(String resolverClassName,
                                                                            String message)

### unableToLocateCustomOptimizerClass

    @LogMessage(level=WARN)
    @Message(value="Unable to interpret specified optimizer [%s], falling back to noop",
             id=321)
    void unableToLocateCustomOptimizerClass(String type)

### unableToInstantiateOptimizer

    @LogMessage(level=WARN)
    @Message(value="Unable to instantiate specified optimizer [%s], falling back to noop",
             id=322)
    void unableToInstantiateOptimizer(String type)

### unableToInstantiateUuidGenerationStrategy

    @LogMessage(level=WARN)
    @Message(value="Unable to instantiate UUID generation strategy class : %s",
             id=325)
    void unableToInstantiateUuidGenerationStrategy(Exception ignore)

### unableToJoinTransaction

    @LogMessage(level=WARN)
    @Message(value="Cannot join transaction: do not override %s",
             id=326)
    void unableToJoinTransaction(String transactionStrategy)

### unableToLoadCommand

    @LogMessage(level=INFO)
    @Message(value="Error performing load command : %s",
             id=327)
    void unableToLoadCommand(HibernateException e)

### unableToLoadDerbyDriver

    @LogMessage(level=WARN)
    @Message(value="Unable to load/access derby driver class sysinfo to check versions : %s",
             id=328)
    void unableToLoadDerbyDriver(String message)

### unableToLoadProperties

    @LogMessage(level=ERROR)
    @Message(value="Problem loading properties from hibernate.properties",
             id=329)
    void unableToLoadProperties()

### unableToLocateConfigFile

    @Message(value="Unable to locate config file: %s",
             id=330)
    String unableToLocateConfigFile(String path)

### unableToLocateConfiguredSchemaNameResolver

    @LogMessage(level=WARN)
    @Message(value="Unable to locate configured schema name resolver class [%s] %s",
             id=331)
    void unableToLocateConfiguredSchemaNameResolver(String resolverClassName,
                                                                       String message)

### unableToLocateMBeanServer

    @LogMessage(level=WARN)
    @Message(value="Unable to locate MBeanServer on JMX service shutdown",
             id=332)
    void unableToLocateMBeanServer()

### unableToLocateUuidGenerationStrategy

    @LogMessage(level=WARN)
    @Message(value="Unable to locate requested UUID generation strategy class : %s",
             id=334)
    void unableToLocateUuidGenerationStrategy(String strategyClassName)

### unableToLogSqlWarnings

    @LogMessage(level=WARN)
    @Message(value="Unable to log SQLWarnings : %s",
             id=335)
    void unableToLogSqlWarnings(SQLException sqle)

### unableToLogWarnings

    @LogMessage(level=WARN)
    @Message(value="Could not log warnings",
             id=336)
    void unableToLogWarnings(@Cause
                                                SQLException e)

### unableToMarkForRollbackOnPersistenceException

    @LogMessage(level=ERROR)
    @Message(value="Unable to mark for rollback on PersistenceException: ",
             id=337)
    void unableToMarkForRollbackOnPersistenceException(@Cause
                                                                          Exception e)

### unableToMarkForRollbackOnTransientObjectException

    @LogMessage(level=ERROR)
    @Message(value="Unable to mark for rollback on TransientObjectException: ",
             id=338)
    void unableToMarkForRollbackOnTransientObjectException(@Cause
                                                                              Exception e)

### unableToObjectConnectionMetadata

    @LogMessage(level=WARN)
    @Message(value="Could not obtain connection metadata: %s",
             id=339)
    void unableToObjectConnectionMetadata(SQLException error)

### unableToObjectConnectionToQueryMetadata

    @LogMessage(level=WARN)
    @Message(value="Could not obtain connection to query metadata: %s",
             id=340)
    void unableToObjectConnectionToQueryMetadata(SQLException error)

### unableToObtainConnectionMetadata

    @LogMessage(level=WARN)
    @Message(value="Could not obtain connection metadata : %s",
             id=341)
    void unableToObtainConnectionMetadata(String message)

### unableToObtainConnectionToQueryMetadata

    @LogMessage(level=WARN)
    @Message(value="Could not obtain connection to query metadata : %s",
             id=342)
    void unableToObtainConnectionToQueryMetadata(String message)

### unableToObtainInitialContext

    @LogMessage(level=ERROR)
    @Message(value="Could not obtain initial context",
             id=343)
    void unableToObtainInitialContext(@Cause
                                                         NamingException e)

### unableToParseMetadata

    @LogMessage(level=ERROR)
    @Message(value="Could not parse the package-level metadata [%s]",
             id=344)
    void unableToParseMetadata(String packageName)

### unableToPerformJdbcCommit

    @Message(value="JDBC commit failed",
             id=345)
    String unableToPerformJdbcCommit()

### unableToPerformManagedFlush

    @LogMessage(level=ERROR)
    @Message(value="Error during managed flush [%s]",
             id=346)
    void unableToPerformManagedFlush(String message)

### unableToQueryDatabaseMetadata

    @Message(value="Unable to query java.sql.DatabaseMetaData",
             id=347)
    String unableToQueryDatabaseMetadata()

### unableToReadClass

    @LogMessage(level=ERROR)
    @Message(value="Unable to read class: %s",
             id=348)
    void unableToReadClass(String message)

### unableToReadColumnValueFromResultSet

    @LogMessage(level=INFO)
    @Message(value="Could not read column value from result set: %s; %s",
             id=349)
    void unableToReadColumnValueFromResultSet(String name,
                                                                 String message)

### unableToReadHiValue

    @Message(value="Could not read a hi value - you need to populate the table: %s",
             id=350)
    String unableToReadHiValue(String tableName)

### unableToReadOrInitHiValue

    @LogMessage(level=ERROR)
    @Message(value="Could not read or init a hi value",
             id=351)
    void unableToReadOrInitHiValue(@Cause
                                                      SQLException e)

### unableToReleaseBatchStatement

    @LogMessage(level=ERROR)
    @Message(value="Unable to release batch statement...",
             id=352)
    void unableToReleaseBatchStatement()

### unableToReleaseCacheLock

    @LogMessage(level=ERROR)
    @Message(value="Could not release a cache lock : %s",
             id=353)
    void unableToReleaseCacheLock(CacheException ce)

### unableToReleaseContext

    @LogMessage(level=INFO)
    @Message(value="Unable to release initial context: %s",
             id=354)
    void unableToReleaseContext(String message)

### unableToReleaseCreatedMBeanServer

    @LogMessage(level=WARN)
    @Message(value="Unable to release created MBeanServer : %s",
             id=355)
    void unableToReleaseCreatedMBeanServer(String string)

### unableToReleaseIsolatedConnection

    @LogMessage(level=INFO)
    @Message(value="Unable to release isolated connection [%s]",
             id=356)
    void unableToReleaseIsolatedConnection(Throwable ignore)

### unableToReleaseTypeInfoResultSet

    @LogMessage(level=WARN)
    @Message(value="Unable to release type info result set",
             id=357)
    void unableToReleaseTypeInfoResultSet()

### unableToRemoveBagJoinFetch

    @LogMessage(level=WARN)
    @Message(value="Unable to erase previously added bag join fetch",
             id=358)
    void unableToRemoveBagJoinFetch()

### unableToResolveAggregateFunction

    @LogMessage(level=INFO)
    @Message(value="Could not resolve aggregate function [%s]; using standard definition",
             id=359)
    void unableToResolveAggregateFunction(String name)

### unableToResolveMappingFile

    @LogMessage(level=INFO)
    @Message(value="Unable to resolve mapping file [%s]",
             id=360)
    void unableToResolveMappingFile(String xmlFile)

### unableToRetrieveCache

    @LogMessage(level=INFO)
    @Message(value="Unable to retreive cache from JNDI [%s]: %s",
             id=361)
    void unableToRetrieveCache(String namespace,
                                                  String message)

### unableToRetrieveTypeInfoResultSet

    @LogMessage(level=WARN)
    @Message(value="Unable to retrieve type info result set : %s",
             id=362)
    void unableToRetrieveTypeInfoResultSet(String string)

### unableToRollbackConnection

    @LogMessage(level=INFO)
    @Message(value="Unable to rollback connection on exception [%s]",
             id=363)
    void unableToRollbackConnection(Exception ignore)

### unableToRollbackIsolatedTransaction

    @LogMessage(level=INFO)
    @Message(value="Unable to rollback isolated transaction on error [%s] : [%s]",
             id=364)
    void unableToRollbackIsolatedTransaction(Exception e,
                                                                Exception ignore)

### unableToRollbackJta

    @Message(value="JTA rollback failed",
             id=365)
    String unableToRollbackJta()

### unableToRunSchemaUpdate

    @LogMessage(level=ERROR)
    @Message(value="Error running schema update",
             id=366)
    void unableToRunSchemaUpdate(@Cause
                                                    Exception e)

### unableToSetTransactionToRollbackOnly

    @LogMessage(level=ERROR)
    @Message(value="Could not set transaction to rollback only",
             id=367)
    void unableToSetTransactionToRollbackOnly(@Cause
                                                                 SystemException e)

### unableToStopHibernateService

    @LogMessage(level=WARN)
    @Message(value="Exception while stopping service",
             id=368)
    void unableToStopHibernateService(@Cause
                                                         Exception e)

### unableToStopService

    @LogMessage(level=INFO)
    @Message(value="Error stopping service [%s] : %s",
             id=369)
    void unableToStopService(Class class1,
                                                String string)

### unableToSwitchToMethodUsingColumnIndex

    @LogMessage(level=WARN)
    @Message(value="Exception switching from method: [%s] to a method using the column index. Reverting to using: [%<s]",
             id=370)
    </FONT>void unableToSwitchToMethodUsingColumnIndex(Method method)

### unableToSynchronizeDatabaseStateWithSession

    @LogMessage(level=ERROR)
    @Message(value="Could not synchronize database state with session: %s",
             id=371)
    void unableToSynchronizeDatabaseStateWithSession(HibernateException he)

### unableToToggleAutoCommit

    @LogMessage(level=ERROR)
    @Message(value="Could not toggle autocommit",
             id=372)
    void unableToToggleAutoCommit(@Cause
                                                     Exception e)

### unableToTransformClass

    @LogMessage(level=ERROR)
    @Message(value="Unable to transform class: %s",
             id=373)
    void unableToTransformClass(String message)

### unableToUnbindFactoryFromJndi

    @LogMessage(level=WARN)
    @Message(value="Could not unbind factory from JNDI",
             id=374)
    void unableToUnbindFactoryFromJndi(@Cause
                                                          JndiException e)

### unableToUpdateHiValue

    @Message(value="Could not update hi value in: %s",
             id=375)
    Object unableToUpdateHiValue(String tableName)

### unableToUpdateQueryHiValue

    @LogMessage(level=ERROR)
    @Message(value="Could not updateQuery hi value in: %s",
             id=376)
    void unableToUpdateQueryHiValue(String tableName,
                                                       @Cause
                                                       SQLException e)

### unableToWrapResultSet

    @LogMessage(level=INFO)
    @Message(value="Error wrapping result set",
             id=377)
    void unableToWrapResultSet(@Cause
                                                  SQLException e)

### unableToWriteCachedFile

    @LogMessage(level=WARN)
    @Message(value="I/O reported error writing cached file : %s: %s",
             id=378)
    void unableToWriteCachedFile(String path,
                                                    String message)

### unexpectedLiteralTokenType

    @LogMessage(level=WARN)
    @Message(value="Unexpected literal token type [%s] passed for numeric processing",
             id=380)
    void unexpectedLiteralTokenType(int type)

### unexpectedRowCounts

    @LogMessage(level=WARN)
    @Message(value="JDBC driver did not return the expected number of row counts",
             id=381)
    void unexpectedRowCounts()

### unknownBytecodeProvider

    @LogMessage(level=WARN)
    @Message(value="unrecognized bytecode provider [%s], using javassist by default",
             id=382)
    void unknownBytecodeProvider(String providerName)

### unknownIngresVersion

    @LogMessage(level=WARN)
    @Message(value="Unknown Ingres major version [%s]; using Ingres 9.2 dialect",
             id=383)
    void unknownIngresVersion(int databaseMajorVersion)

### unknownOracleVersion

    @LogMessage(level=WARN)
    @Message(value="Unknown Oracle major version [%s]",
             id=384)
    void unknownOracleVersion(int databaseMajorVersion)

### unknownSqlServerVersion

    @LogMessage(level=WARN)
    @Message(value="Unknown Microsoft SQL Server major version [%s] using SQL Server 2000 dialect",
             id=385)
    void unknownSqlServerVersion(int databaseMajorVersion)

### unregisteredResultSetWithoutStatement

    @LogMessage(level=WARN)
    @Message(value="ResultSet had no statement associated with it, but was not yet registered",
             id=386)
    void unregisteredResultSetWithoutStatement()

### unregisteredStatement

    @LogMessage(level=WARN)
    @Message(value="ResultSet\'s statement was not registered",
             id=387)
    void unregisteredStatement()

### unsuccessful

    @LogMessage(level=ERROR)
    @Message(value="Unsuccessful: %s",
             id=388)
    void unsuccessful(String sql)

### unsuccessfulCreate

    @LogMessage(level=ERROR)
    @Message(value="Unsuccessful: %s",
             id=389)
    void unsuccessfulCreate(String string)

### unsupportedAfterStatement

    @LogMessage(level=WARN)
    @Message(value="Overriding release mode as connection provider does not support \'after_statement\'",
             id=390)
    void unsupportedAfterStatement()

### unsupportedIngresVersion

    @LogMessage(level=WARN)
    @Message(value="Ingres 10 is not yet fully supported; using Ingres 9.3 dialect",
             id=391)
    void unsupportedIngresVersion()

### unsupportedInitialValue

    @LogMessage(level=WARN)
    @Message(value="Hibernate does not support SequenceGenerator.initialValue() unless \'%s\' set",
             id=392)
    void unsupportedInitialValue(String propertyName)

### unsupportedMultiTableBulkHqlJpaql

    @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/jpaql will not work properly",
             id=393)
    void unsupportedMultiTableBulkHqlJpaql(int majorVersion,
                                                              int minorVersion,
                                                              int buildId)

### unsupportedOracleVersion

    @LogMessage(level=WARN)
    @Message(value="Oracle 11g is not yet fully supported; using Oracle 10g dialect",
             id=394)
    void unsupportedOracleVersion()

### unsupportedProperty

    @LogMessage(level=WARN)
    @Message(value="Usage of obsolete property: %s no longer supported, use: %s",
             id=395)
    void unsupportedProperty(Object propertyName,
                                                Object newPropertyName)

### updatingSchema

    @LogMessage(level=INFO)
    @Message(value="Updating schema",
             id=396)
    void updatingSchema()

### usingAstQueryTranslatorFactory

    @LogMessage(level=INFO)
    @Message(value="Using ASTQueryTranslatorFactory",
             id=397)
    void usingAstQueryTranslatorFactory()

### usingDefaultIdGeneratorSegmentValue

    @LogMessage(level=INFO)
    @Message(value="Explicit segment value for id generator [%s.%s] suggested; using default [%s]",
             id=398)
    void usingDefaultIdGeneratorSegmentValue(String tableName,
                                                                String segmentColumnName,
                                                                String defaultToUse)

### usingDefaultTransactionStrategy

    @LogMessage(level=INFO)
    @Message(value="Using default transaction strategy (direct JDBC transactions)",
             id=399)
    void usingDefaultTransactionStrategy()

### usingDialect

    @LogMessage(level=INFO)
    @Message(value="Using dialect: %s",
             id=400)
    void usingDialect(Dialect dialect)

### usingDriver

    @LogMessage(level=INFO)
    @Message(value="using driver [%s] at URL [%s]",
             id=401)
    void usingDriver(String driverClassName,
                                        String url)

### usingHibernateBuiltInConnectionPool

    @LogMessage(level=INFO)
    @Message(value="Using Hibernate built-in connection pool (not for production use!)",
             id=402)
    void usingHibernateBuiltInConnectionPool()

### usingOldDtd

    @LogMessage(level=ERROR)
    @Message(value="Don\'t use old DTDs, read the Hibernate 3.x Migration Guide!",
             id=404)
    void usingOldDtd()

### usingReflectionOptimizer

    @LogMessage(level=INFO)
    @Message(value="Using bytecode reflection optimizer",
             id=406)
    void usingReflectionOptimizer()

### usingStreams

    @LogMessage(level=INFO)
    @Message(value="Using java.io streams to persist binary types",
             id=407)
    void usingStreams()

### usingTimestampWorkaround

    @LogMessage(level=INFO)
    @Message(value="Using workaround for JVM bug in java.sql.Timestamp",
             id=408)
    void usingTimestampWorkaround()

### usingUuidHexGenerator

    @LogMessage(level=WARN)
    @Message(value="Using %s which does not generate IETF RFC 4122 compliant UUID values; consider using %s instead",
             id=409)
    void usingUuidHexGenerator(String name,
                                                  String name2)

### validatorNotFound

    @LogMessage(level=INFO)
    @Message(value="Hibernate Validator not found: ignoring",
             id=410)
    void validatorNotFound()

### version

    @LogMessage(level=INFO)
    @Message(value="Hibernate Core {%s}",
             id=412)
    void version(String versionString)

### warningsCreatingTempTable

    @LogMessage(level=WARN)
    @Message(value="Warnings creating temp table : %s",
             id=413)
    void warningsCreatingTempTable(SQLWarning warning)

### willNotRegisterListeners

    @LogMessage(level=INFO)
    @Message(value="Property hibernate.search.autoregister_listeners is set to false. No attempt will be made to register Hibernate Search event listeners.",
             id=414)
    void willNotRegisterListeners()

### writeLocksNotSupported

    @LogMessage(level=WARN)
    @Message(value="Write locks via update not supported for non-versioned entities [%s]",
             id=416)
    void writeLocksNotSupported(String entityName)

### writingGeneratedSchemaToFile

    @LogMessage(level=INFO)
    @Message(value="Writing generated schema to file: %s",
             id=417)
    void writingGeneratedSchemaToFile(String outputFile)

### addingOverrideFor

    @LogMessage(level=INFO)
    @Message(value="Adding override for %s: %s",
             id=418)
    void addingOverrideFor(String name,
                                              String name2)

### resolvedSqlTypeDescriptorForDifferentSqlCode

    @LogMessage(level=WARN)
    @Message(value="Resolved SqlTypeDescriptor is for a different SQL code. %s has sqlCode=%s; type override %s has sqlCode=%s",
             id=419)
    void resolvedSqlTypeDescriptorForDifferentSqlCode(String name,
                                                                         String valueOf,
                                                                         String name2,
                                                                         String valueOf2)

### closingUnreleasedBatch

    @LogMessage(level=DEBUG)
    @Message(value="Closing un-released batch",
             id=420)
    void closingUnreleasedBatch()

### disablingContextualLOBCreation

    @LogMessage(level=INFO)
    @Message(value="Disabling contextual LOB creation as %s is true",
             id=421)
    void disablingContextualLOBCreation(String nonContextualLobCreation)

### disablingContextualLOBCreationSinceConnectionNull

    @LogMessage(level=INFO)
    @Message(value="Disabling contextual LOB creation as connection was null",
             id=422)
    void disablingContextualLOBCreationSinceConnectionNull()

### disablingContextualLOBCreationSinceOldJdbcVersion

    @LogMessage(level=INFO)
    @Message(value="Disabling contextual LOB creation as JDBC driver reported JDBC version [%s] less than 4",
             id=423)
    void disablingContextualLOBCreationSinceOldJdbcVersion(int jdbcMajorVersion)

### disablingContextualLOBCreationSinceCreateClobFailed

    @LogMessage(level=INFO)
    @Message(value="Disabling contextual LOB creation as createClob() method threw error : %s",
             id=424)
    void disablingContextualLOBCreationSinceCreateClobFailed(Throwable t)

### unableToCloseSessionButSwallowingError

    @LogMessage(level=INFO)
    @Message(value="Could not close session; swallowing exception[%s] as transaction completed",
             id=425)
    void unableToCloseSessionButSwallowingError(HibernateException e)

### setManagerLookupClass

    @LogMessage(level=WARN)
    @Message(value="You should set hibernate.transaction.manager_lookup_class if cache is enabled",
             id=426)
    void setManagerLookupClass()

### deprecatedTransactionManagerStrategy

    @LogMessage(level=WARN)
    @Message(value="Using deprecated %s strategy [%s], use newer %s strategy instead [%s]",
             id=427)
    void deprecatedTransactionManagerStrategy(String name,
                                                                 String transactionManagerStrategy,
                                                                 String name2,
                                                                 String jtaPlatform)

### legacyTransactionManagerStrategy

    @LogMessage(level=INFO)
    @Message(value="Encountered legacy TransactionManagerLookup specified; convert to newer %s contract specified via %s setting",
             id=428)
    void legacyTransactionManagerStrategy(String name,
                                                             String jtaPlatform)

### entityIdentifierValueBindingExists

    @LogMessage(level=WARN)
    @Message(value="Setting entity-identifier value binding where one already existed : %s.",
             id=429)
    void entityIdentifierValueBindingExists(String name)

### deprecatedDerbyDialect

    @LogMessage(level=WARN)
    @Message(value="The DerbyDialect dialect has been deprecated; use one of the version-specific dialects instead",
             id=430)
    void deprecatedDerbyDialect()

### undeterminedH2Version

    @LogMessage(level=WARN)
    @Message(value="Unable to determine H2 database version, certain features may not work",
             id=431)
    void undeterminedH2Version()

### noColumnsSpecifiedForIndex

    @LogMessage(level=WARN)
    @Message(value="There were not column names specified for index %s on table %s",
             id=432)
    void noColumnsSpecifiedForIndex(String indexName,
                                                       String tableName)

### timestampCachePuts

    @LogMessage(level=INFO)
    @Message(value="update timestamps cache puts: %s",
             id=433)
    void timestampCachePuts(long updateTimestampsCachePutCount)

### timestampCacheHits

    @LogMessage(level=INFO)
    @Message(value="update timestamps cache hits: %s",
             id=434)
    void timestampCacheHits(long updateTimestampsCachePutCount)

### timestampCacheMisses

    @LogMessage(level=INFO)
    @Message(value="update timestamps cache misses: %s",
             id=435)
    void timestampCacheMisses(long updateTimestampsCachePutCount)

### entityManagerFactoryAlreadyRegistered

    @LogMessage(level=WARN)
    @Message(value="Entity manager factory name (%s) is already registered.  If entity manager will be clustered or passivated, specify a unique value for property \'%s\'",
             id=436)
    void entityManagerFactoryAlreadyRegistered(String emfName,
                                                                  String propertyName)

### cannotResolveNonNullableTransientDependencies

    @LogMessage(level=WARN)
    @Message(value="Attempting to save one or more entities that have a non-nullable association with an unsaved transient entity. The unsaved transient entity must be saved in an operation prior to saving these dependent entities.\n\tUnsaved transient entity: (%s)\n\tDependent entities: (%s)\n\tNon-nullable association(s): (%s)",
             id=437)
    void cannotResolveNonNullableTransientDependencies(String transientEntityString,
                                                                          Set<String> dependentEntityStrings,
                                                                          Set<String> nonNullableAssociationPaths)

### naturalIdCachePuts

    @LogMessage(level=INFO)
    @Message(value="NaturalId cache puts: %s",
             id=438)
    void naturalIdCachePuts(long naturalIdCachePutCount)

### naturalIdCacheHits

    @LogMessage(level=INFO)
    @Message(value="NaturalId cache hits: %s",
             id=439)
    void naturalIdCacheHits(long naturalIdCacheHitCount)

### naturalIdCacheMisses

    @LogMessage(level=INFO)
    @Message(value="NaturalId cache misses: %s",
             id=440)
    void naturalIdCacheMisses(long naturalIdCacheMissCount)

### naturalIdMaxQueryTime

    @LogMessage(level=INFO)
    @Message(value="Max NaturalId query time: %sms",
             id=441)
    void naturalIdMaxQueryTime(long naturalIdQueryExecutionMaxTime)

### naturalIdQueriesExecuted

    @LogMessage(level=INFO)
    @Message(value="NaturalId queries executed to database: %s",
             id=442)
    void naturalIdQueriesExecuted(long naturalIdQueriesExecutionCount)

Copyright © 2001-2012 Red Hat, Inc. All Rights Reserved.