CoreMessageLogger (Hibernate JavaDocs)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

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
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

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: [%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)